From c9d971bbf173cd75307ff0802348af65036519ca Mon Sep 17 00:00:00 2001 From: Konrad Pabjan Date: Wed, 25 Oct 2023 16:37:50 -0400 Subject: [PATCH] Add artifact-id to outputs --- README.md | 159 +- action.yml | 8 +- dist/index.js | 13354 +++++++++++++++++++-------------------- src/upload-artifact.ts | 9 +- 4 files changed, 6749 insertions(+), 6781 deletions(-) diff --git a/README.md b/README.md index 0da14ce..8def9d8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,6 @@ -# Upload-Artifact v3 +# Upload-Artifact v4 beta + +❗ Not publicly available. If you try to use this version then it will fail. Available only internally at GitHub while in development. Stay tuned for public announcements soon about broader availability❗ This uploads artifacts from your workflow allowing you to share data between jobs and store data once a workflow is complete. @@ -6,19 +8,11 @@ See also [download-artifact](https://github.com/actions/download-artifact). # What's new -- Easier upload - - Specify a wildcard pattern - - Specify an individual file - - Specify a directory (previously you were limited to only this option) - - Multi path upload - - Use a combination of individual files, wildcards or directories - - Support for excluding certain files -- Upload an artifact without providing a name -- Fix for artifact uploads sometimes not working with containers -- Proxy support out of the box -- Port entire action to typescript from a runner plugin so it is easier to collaborate and accept contributions +🚧 Under construction 🚧 -Refer [here](https://github.com/actions/upload-artifact/tree/releases/v1) for the previous version +Big changes coming... + +Refer [here](https://github.com/actions/upload-artifact/tree/releases/v3) for the previous version # Usage @@ -34,7 +28,7 @@ steps: - run: echo hello > path/to/artifact/world.txt -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: name: my-artifact path: path/to/artifact/world.txt @@ -43,7 +37,7 @@ steps: ### Upload an Entire Directory ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: name: my-artifact path: path/to/artifact/ # or path/to/artifact @@ -52,7 +46,7 @@ steps: ### Upload using a Wildcard Pattern ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: name: my-artifact path: path/**/[abc]rtifac?/* @@ -61,7 +55,7 @@ steps: ### Upload using Multiple Paths and Exclusions ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: name: my-artifact path: | @@ -97,7 +91,7 @@ The [@actions/artifact](https://github.com/actions/toolkit/tree/main/packages/ar If a path (or paths), result in no files being found for the artifact, the action will succeed but print out a warning. In certain scenarios it may be desirable to fail the action or suppress the warning. The `if-no-files-found` option allows you to customize the behavior of the action if no files are found: ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: name: my-artifact path: path/to/artifact/ @@ -109,7 +103,7 @@ If a path (or paths), result in no files being found for the artifact, the actio To upload artifacts only when the previous step of a job failed, use [`if: failure()`](https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions#job-status-check-functions): ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta if: failure() with: name: my-artifact @@ -121,7 +115,7 @@ To upload artifacts only when the previous step of a job failed, use [`if: failu You can upload an artifact without specifying a name ```yaml -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: path: path/to/artifact/world.txt ``` @@ -130,51 +124,21 @@ If not provided, `artifact` will be used as the default name which will manifest ### Uploading to the same artifact -With the following example, the available artifact (named `artifact` by default if no name is provided) would contain both `world.txt` (`hello`) and `extra-file.txt` (`howdy`): +Unlike earlier versions of `upload-artifact`, uploading to the same artifact via multiple jobs is _not_ supported with `v4`. ```yaml - run: echo hi > world.txt -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: path: world.txt - run: echo howdy > extra-file.txt -- uses: actions/upload-artifact@v3 +- uses: actions/upload-artifact@v4-beta with: path: extra-file.txt - -- run: echo hello > world.txt -- uses: actions/upload-artifact@v3 - with: - path: world.txt ``` -Each artifact behaves as a file share. Uploading to the same artifact multiple times in the same workflow can overwrite and append already uploaded files: - -```yaml - strategy: - matrix: - node-version: [8.x, 10.x, 12.x, 13.x] - steps: - - name: Create a file - run: echo ${{ matrix.node-version }} > my_file.txt - - name: Accidentally upload to the same artifact via multiple jobs - uses: actions/upload-artifact@v3 - with: - name: my-artifact - path: ${{ github.workspace }} -``` - -> **_Warning:_** Be careful when uploading to the same artifact via multiple jobs as artifacts may become corrupted. When uploading a file with an identical name and path in multiple jobs, uploads may fail with 503 errors due to conflicting uploads happening at the same time. Ensure uploads to identical locations to not interfere with each other. - -In the above example, four jobs will upload four different files to the same artifact but there will only be one file available when `my-artifact` is downloaded. Each job overwrites what was previously uploaded. To ensure that jobs don't overwrite existing artifacts, use a different name per job: - -```yaml - uses: actions/upload-artifact@v3 - with: - name: my-artifact ${{ matrix.node-version }} - path: ${{ github.workspace }} -``` +Artifact names must be unique since each created artifact is idempotent so multiple jobs cannot modify the same artifact. ### Environment Variables and Tilde Expansion @@ -184,9 +148,9 @@ You can use `~` in the path input as a substitute for `$HOME`. Basic tilde expan - run: | mkdir -p ~/new/artifact echo hello > ~/new/artifact/world.txt - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4-beta with: - name: Artifacts-V3 + name: Artifacts-V4-beta path: ~/new/**/* ``` @@ -199,7 +163,7 @@ Environment variables along with context expressions can also be used for input. - run: | mkdir -p ${{ github.workspace }}/artifact echo hello > ${{ github.workspace }}/artifact/world.txt - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4-beta with: name: ${{ env.name }}-name path: ${{ github.workspace }}/artifact/**/* @@ -213,7 +177,7 @@ For environment variables created in other steps, make sure to use the `env` exp mkdir testing echo "This is a file to upload" > testing/file.txt echo "artifactPath=testing/file.txt" >> $GITHUB_ENV - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4-beta with: name: artifact path: ${{ env.artifactPath }} # this will resolve to testing/file.txt at runtime @@ -228,7 +192,7 @@ Artifacts are retained for 90 days by default. You can specify a shorter retenti run: echo "I won't live long" > my_file.txt - name: Upload Artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4-beta with: name: my-artifact path: my_file.txt @@ -237,6 +201,46 @@ Artifacts are retained for 90 days by default. You can specify a shorter retenti The retention period must be between 1 and 90 inclusive. For more information see [artifact and log retention policies](https://docs.github.com/en/free-pro-team@latest/actions/reference/usage-limits-billing-and-administration#artifact-and-log-retention-policy). +## Outputs + +If an artifact upload is successful then an `artifact-id` output is available. This ID is a unique identifier that can be used with [Artifact REST APIs](https://docs.github.com/en/rest/actions/artifacts). + +### Example output between steps + +```yml + - uses: actions/upload-artifact@v4-beta + id: artifact-upload-step + with: + name: my-artifact + path: path/to/artifact/content/ + + - name: Output artifact ID + run: echo 'Artifact ID is ${{ steps.artifact-upload-step.outputs.artifact-id }}' +``` + +### Example output between jobs + +```yml +jobs: + job1: + runs-on: ubuntu-latest + outputs: + output1: ${{ steps.my-artifact.outputs.artifact-id }} + steps: + - uses: actions/upload-artifact@v4-beta + id: artifact-upload-step + with: + name: my-artifact + path: path/to/artifact/content/ + job2: + runs-on: ubuntu-latest + needs: job1 + steps: + - env: + OUTPUT1: ${{needs.job1.outputs.output1}} + run: echo "Artifact ID from previous job is $OUTPUT1" +``` + ## Where does the upload go? At the bottom of the workflow summary page, there is a dedicated section for artifacts. Here's a screenshot of something you might see: @@ -245,42 +249,7 @@ At the bottom of the workflow summary page, there is a dedicated section for art There is a trashcan icon that can be used to delete the artifact. This icon will only appear for users who have write permissions to the repository. -The size of the artifact is denoted in bytes. The displayed artifact size denotes the raw uploaded artifact size (the sum of all the individual files uploaded during the workflow run for the artifact), not the compressed size. When you click to download an artifact from the summary page, a compressed zip is created with all the contents of the artifact and the size of the zip that you download may differ significantly from the displayed size. Billing is based on the raw uploaded size and not the size of the zip. - -# Limitations - -### Zipped Artifact Downloads - -During a workflow run, files are uploaded and downloaded individually using the `upload-artifact` and `download-artifact` actions. However, when a workflow run finishes and an artifact is downloaded from either the UI or through the [download api](https://developer.github.com/v3/actions/artifacts/#download-an-artifact), a zip is dynamically created with all the file contents that were uploaded. There is currently no way to download artifacts after a workflow run finishes in a format other than a zip or to download artifact contents individually. One of the consequences of this limitation is that if a zip is uploaded during a workflow run and then downloaded from the UI, there will be a double zip created. - -### Permission Loss - -:exclamation: File permissions are not maintained during artifact upload :exclamation: For example, if you make a file executable using `chmod` and then upload that file, post-download the file is no longer guaranteed to be set as an executable. - -### Case Insensitive Uploads - -:exclamation: File uploads are case insensitive :exclamation: If you upload `A.txt` and `a.txt` with the same root path, only a single file will be saved and available during download. - -### Maintaining file permissions and case sensitive files - -If file permissions and case sensitivity are required, you can `tar` all of your files together before artifact upload. Post download, the `tar` file will maintain file permissions and case sensitivity: - -```yaml - - name: Tar files - run: tar -cvf my_files.tar /path/to/my/directory - - - name: Upload Artifact - uses: actions/upload-artifact@v3 - with: - name: my-artifact - path: my_files.tar -``` - -### Too many uploads resulting in 429 responses - -A very minute subset of users who upload a very very large amount of artifacts in a short period of time may see their uploads throttled or fail because of `Request was blocked due to exceeding usage of resource 'DBCPU' in namespace` or `Unable to copy file to server StatusCode=TooManyRequests`. - -To reduce the chance of this happening, you can reduce the number of HTTP calls made during artifact upload by zipping or archiving the contents of your artifact before an upload starts. As an example, imagine an artifact with 1000 files (each 10 Kb in size). Without any modification, there would be around 1000 HTTP calls made to upload the artifact. If you zip or archive the artifact beforehand, the number of HTTP calls can be dropped to single digit territory. Measures like this will significantly speed up your upload and prevent uploads from being throttled or in some cases fail. +The size of the artifact is denoted in bytes. The displayed artifact size denotes the size of the zip that `upload-artifact` creates during upload. ## Additional Documentation diff --git a/action.yml b/action.yml index 94a583a..163b233 100644 --- a/action.yml +++ b/action.yml @@ -23,6 +23,12 @@ inputs: Minimum 1 day. Maximum 90 days unless changed from the repository settings page. +outputs: + artifact-id: + description: > + A unique identifier for the artifact that was just uploaded. Empty if artifact upload failed. + + This ID can be used as input to other APIs to download, delete or get more information about an artifact: https://docs.github.com/en/rest/actions/artifacts runs: - using: 'node16' + using: 'node20' main: 'dist/index.js' diff --git a/dist/index.js b/dist/index.js index 3ede196..1dc11e8 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,13 +1,5137 @@ /******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ -/***/ 56966: +/***/ 87351: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.issue = exports.issueCommand = void 0; +const os = __importStar(__nccwpck_require__(22037)); +const utils_1 = __nccwpck_require__(5278); +/** + * Commands + * + * Command Format: + * ::name key=value,key=value::message + * + * Examples: + * ::warning::This is the message + * ::set-env name=MY_VAR::some value + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); +} +exports.issueCommand = issueCommand; +function issue(name, message = '') { + issueCommand(name, {}, message); +} +exports.issue = issue; +const CMD_STRING = '::'; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } + else { + cmdStr += ','; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } +} +function escapeData(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A'); +} +function escapeProperty(s) { + return utils_1.toCommandValue(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/:/g, '%3A') + .replace(/,/g, '%2C'); +} +//# sourceMappingURL=command.js.map + +/***/ }), + +/***/ 42186: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; +const command_1 = __nccwpck_require__(87351); +const file_command_1 = __nccwpck_require__(717); +const utils_1 = __nccwpck_require__(5278); +const os = __importStar(__nccwpck_require__(22037)); +const path = __importStar(__nccwpck_require__(71017)); +const oidc_utils_1 = __nccwpck_require__(98041); +/** + * The code to exit an action + */ +var ExitCode; +(function (ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +//----------------------------------------------------------------------- +// Variables +//----------------------------------------------------------------------- +/** + * Sets env variable for this action and future actions in the job + * @param name the name of the variable to set + * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function exportVariable(name, val) { + const convertedVal = utils_1.toCommandValue(val); + process.env[name] = convertedVal; + const filePath = process.env['GITHUB_ENV'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); + } + command_1.issueCommand('set-env', { name }, convertedVal); +} +exports.exportVariable = exportVariable; +/** + * Registers a secret which will get masked from logs + * @param secret value of the secret + */ +function setSecret(secret) { + command_1.issueCommand('add-mask', {}, secret); +} +exports.setSecret = setSecret; +/** + * Prepends inputPath to the PATH (for this action and future actions) + * @param inputPath + */ +function addPath(inputPath) { + const filePath = process.env['GITHUB_PATH'] || ''; + if (filePath) { + file_command_1.issueFileCommand('PATH', inputPath); + } + else { + command_1.issueCommand('add-path', {}, inputPath); + } + process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; +} +exports.addPath = addPath; +/** + * Gets the value of an input. + * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. + * Returns an empty string if the value is not defined. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string + */ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); +} +exports.getInput = getInput; +/** + * Gets the values of an multiline input. Each value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string[] + * + */ +function getMultilineInput(name, options) { + const inputs = getInput(name, options) + .split('\n') + .filter(x => x !== ''); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map(input => input.trim()); +} +exports.getMultilineInput = getMultilineInput; +/** + * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. + * Support boolean input list: `true | True | TRUE | false | False | FALSE` . + * The return value is also in boolean type. + * ref: https://yaml.org/spec/1.2/spec.html#id2804923 + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns boolean + */ +function getBooleanInput(name, options) { + const trueValue = ['true', 'True', 'TRUE']; + const falseValue = ['false', 'False', 'FALSE']; + const val = getInput(name, options); + if (trueValue.includes(val)) + return true; + if (falseValue.includes(val)) + return false; + throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + + `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); +} +exports.getBooleanInput = getBooleanInput; +/** + * Sets the value of an output. + * + * @param name name of the output to set + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function setOutput(name, value) { + const filePath = process.env['GITHUB_OUTPUT'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value)); + } + process.stdout.write(os.EOL); + command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); +} +exports.setOutput = setOutput; +/** + * Enables or disables the echoing of commands into stdout for the rest of the step. + * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. + * + */ +function setCommandEcho(enabled) { + command_1.issue('echo', enabled ? 'on' : 'off'); +} +exports.setCommandEcho = setCommandEcho; +//----------------------------------------------------------------------- +// Results +//----------------------------------------------------------------------- +/** + * Sets the action status to failed. + * When the action exits it will be with an exit code of 1 + * @param message add error issue message + */ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +exports.setFailed = setFailed; +//----------------------------------------------------------------------- +// Logging Commands +//----------------------------------------------------------------------- +/** + * Gets whether Actions Step Debug is on or not + */ +function isDebug() { + return process.env['RUNNER_DEBUG'] === '1'; +} +exports.isDebug = isDebug; +/** + * Writes debug message to user log + * @param message debug message + */ +function debug(message) { + command_1.issueCommand('debug', {}, message); +} +exports.debug = debug; +/** + * Adds an error issue + * @param message error issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function error(message, properties = {}) { + command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.error = error; +/** + * Adds a warning issue + * @param message warning issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function warning(message, properties = {}) { + command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.warning = warning; +/** + * Adds a notice issue + * @param message notice issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function notice(message, properties = {}) { + command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); +} +exports.notice = notice; +/** + * Writes info to log with console.log. + * @param message info message + */ +function info(message) { + process.stdout.write(message + os.EOL); +} +exports.info = info; +/** + * Begin an output group. + * + * Output until the next `groupEnd` will be foldable in this group + * + * @param name The name of the output group + */ +function startGroup(name) { + command_1.issue('group', name); +} +exports.startGroup = startGroup; +/** + * End an output group. + */ +function endGroup() { + command_1.issue('endgroup'); +} +exports.endGroup = endGroup; +/** + * Wrap an asynchronous function call in a group. + * + * Returns the same type as the function itself. + * + * @param name The name of the group + * @param fn The function to wrap in the group + */ +function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } + finally { + endGroup(); + } + return result; + }); +} +exports.group = group; +//----------------------------------------------------------------------- +// Wrapper action state +//----------------------------------------------------------------------- +/** + * Saves state for current action, the state can only be retrieved by this action's post job execution. + * + * @param name name of the state to store + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function saveState(name, value) { + const filePath = process.env['GITHUB_STATE'] || ''; + if (filePath) { + return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value)); + } + command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value)); +} +exports.saveState = saveState; +/** + * Gets the value of an state set by this action's main execution. + * + * @param name name of the state to get + * @returns string + */ +function getState(name) { + return process.env[`STATE_${name}`] || ''; +} +exports.getState = getState; +function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); +} +exports.getIDToken = getIDToken; +/** + * Summary exports + */ +var summary_1 = __nccwpck_require__(81327); +Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); +/** + * @deprecated use core.summary + */ +var summary_2 = __nccwpck_require__(81327); +Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); +/** + * Path exports + */ +var path_utils_1 = __nccwpck_require__(2981); +Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); +Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); +Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); +//# sourceMappingURL=core.js.map + +/***/ }), + +/***/ 717: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +// For internal use, subject to change. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +const fs = __importStar(__nccwpck_require__(57147)); +const os = __importStar(__nccwpck_require__(22037)); +const uuid_1 = __nccwpck_require__(75840); +const utils_1 = __nccwpck_require__(5278); +function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { + encoding: 'utf8' + }); +} +exports.issueFileCommand = issueFileCommand; +function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${uuid_1.v4()}`; + const convertedValue = utils_1.toCommandValue(value); + // These should realistically never happen, but just in case someone finds a + // way to exploit uuid generation let's not allow keys or values that contain + // the delimiter. + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; +} +exports.prepareKeyValueMessage = prepareKeyValueMessage; +//# sourceMappingURL=file-command.js.map + +/***/ }), + +/***/ 98041: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OidcClient = void 0; +const http_client_1 = __nccwpck_require__(96255); +const auth_1 = __nccwpck_require__(35526); +const core_1 = __nccwpck_require__(42186); +class OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; + if (!token) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; + if (!runtimeUrl) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = OidcClient.createHttpClient(); + const res = yield httpclient + .getJson(id_token_url) + .catch(error => { + throw new Error(`Failed to get ID Token. \n + Error Code : ${error.statusCode}\n + Error Message: ${error.result.message}`); + }); + const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; + if (!id_token) { + throw new Error('Response json body do not have ID Token field'); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + // New ID Token is requested from action service + let id_token_url = OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + core_1.debug(`ID token url is ${id_token_url}`); + const id_token = yield OidcClient.getCall(id_token_url); + core_1.setSecret(id_token); + return id_token; + } + catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } +} +exports.OidcClient = OidcClient; +//# sourceMappingURL=oidc-utils.js.map + +/***/ }), + +/***/ 2981: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = void 0; +const path = __importStar(__nccwpck_require__(71017)); +/** + * toPosixPath converts the given path to the posix form. On Windows, \\ will be + * replaced with /. + * + * @param pth. Path to transform. + * @return string Posix path. + */ +function toPosixPath(pth) { + return pth.replace(/[\\]/g, '/'); +} +exports.toPosixPath = toPosixPath; +/** + * toWin32Path converts the given path to the win32 form. On Linux, / will be + * replaced with \\. + * + * @param pth. Path to transform. + * @return string Win32 path. + */ +function toWin32Path(pth) { + return pth.replace(/[/]/g, '\\'); +} +exports.toWin32Path = toWin32Path; +/** + * toPlatformPath converts the given path to a platform-specific path. It does + * this by replacing instances of / and \ with the platform-specific path + * separator. + * + * @param pth The path to platformize. + * @return string The platform-specific path. + */ +function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path.sep); +} +exports.toPlatformPath = toPlatformPath; +//# sourceMappingURL=path-utils.js.map + +/***/ }), + +/***/ 81327: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0; +const os_1 = __nccwpck_require__(22037); +const fs_1 = __nccwpck_require__(57147); +const { access, appendFile, writeFile } = fs_1.promises; +exports.SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY'; +exports.SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary'; +class Summary { + constructor() { + this._buffer = ''; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } + catch (_a) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs) + .map(([key, value]) => ` ${key}="${value}"`) + .join(''); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: 'utf8' }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ''; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, (lang && { lang })); + const element = this.wrap('pre', this.wrap('code', code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const listItems = items.map(item => this.wrap('li', item)).join(''); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows + .map(row => { + const cells = row + .map(cell => { + if (typeof cell === 'string') { + return this.wrap('td', cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? 'th' : 'td'; + const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan })); + return this.wrap(tag, data, attrs); + }) + .join(''); + return this.wrap('tr', cells); + }) + .join(''); + const element = this.wrap('table', tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap('details', this.wrap('summary', label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height })); + const element = this.wrap('img', null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag) + ? tag + : 'h1'; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap('hr', null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap('br', null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, (cite && { cite })); + const element = this.wrap('blockquote', text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap('a', text, { href }); + return this.addRaw(element).addEOL(); + } +} +const _summary = new Summary(); +/** + * @deprecated use `core.summary` + */ +exports.markdownSummary = _summary; +exports.summary = _summary; +//# sourceMappingURL=summary.js.map + +/***/ }), + +/***/ 5278: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toCommandProperties = exports.toCommandValue = void 0; +/** + * Sanitizes an input into a string so it can be passed into issueCommand safely + * @param input input to sanitize into a string + */ +function toCommandValue(input) { + if (input === null || input === undefined) { + return ''; + } + else if (typeof input === 'string' || input instanceof String) { + return input; + } + return JSON.stringify(input); +} +exports.toCommandValue = toCommandValue; +/** + * + * @param annotationProperties + * @returns The command properties to send with the actual annotation command + * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 + */ +function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; +} +exports.toCommandProperties = toCommandProperties; +//# sourceMappingURL=utils.js.map + +/***/ }), + +/***/ 28090: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.hashFiles = exports.create = void 0; +const internal_globber_1 = __nccwpck_require__(28298); +const internal_hash_files_1 = __nccwpck_require__(2448); +/** + * Constructs a globber + * + * @param patterns Patterns separated by newlines + * @param options Glob options + */ +function create(patterns, options) { + return __awaiter(this, void 0, void 0, function* () { + return yield internal_globber_1.DefaultGlobber.create(patterns, options); + }); +} +exports.create = create; +/** + * Computes the sha256 hash of a glob + * + * @param patterns Patterns separated by newlines + * @param options Glob options + */ +function hashFiles(patterns, options, verbose = false) { + return __awaiter(this, void 0, void 0, function* () { + let followSymbolicLinks = true; + if (options && typeof options.followSymbolicLinks === 'boolean') { + followSymbolicLinks = options.followSymbolicLinks; + } + const globber = yield create(patterns, { followSymbolicLinks }); + return internal_hash_files_1.hashFiles(globber, verbose); + }); +} +exports.hashFiles = hashFiles; +//# sourceMappingURL=glob.js.map + +/***/ }), + +/***/ 51026: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getOptions = void 0; +const core = __importStar(__nccwpck_require__(42186)); +/** + * Returns a copy with defaults filled in. + */ +function getOptions(copy) { + const result = { + followSymbolicLinks: true, + implicitDescendants: true, + matchDirectories: true, + omitBrokenSymbolicLinks: true + }; + if (copy) { + if (typeof copy.followSymbolicLinks === 'boolean') { + result.followSymbolicLinks = copy.followSymbolicLinks; + core.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`); + } + if (typeof copy.implicitDescendants === 'boolean') { + result.implicitDescendants = copy.implicitDescendants; + core.debug(`implicitDescendants '${result.implicitDescendants}'`); + } + if (typeof copy.matchDirectories === 'boolean') { + result.matchDirectories = copy.matchDirectories; + core.debug(`matchDirectories '${result.matchDirectories}'`); + } + if (typeof copy.omitBrokenSymbolicLinks === 'boolean') { + result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks; + core.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`); + } + } + return result; +} +exports.getOptions = getOptions; +//# sourceMappingURL=internal-glob-options-helper.js.map + +/***/ }), + +/***/ 28298: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.DefaultGlobber = void 0; +const core = __importStar(__nccwpck_require__(42186)); +const fs = __importStar(__nccwpck_require__(57147)); +const globOptionsHelper = __importStar(__nccwpck_require__(51026)); +const path = __importStar(__nccwpck_require__(71017)); +const patternHelper = __importStar(__nccwpck_require__(29005)); +const internal_match_kind_1 = __nccwpck_require__(81063); +const internal_pattern_1 = __nccwpck_require__(64536); +const internal_search_state_1 = __nccwpck_require__(89117); +const IS_WINDOWS = process.platform === 'win32'; +class DefaultGlobber { + constructor(options) { + this.patterns = []; + this.searchPaths = []; + this.options = globOptionsHelper.getOptions(options); + } + getSearchPaths() { + // Return a copy + return this.searchPaths.slice(); + } + glob() { + var e_1, _a; + return __awaiter(this, void 0, void 0, function* () { + const result = []; + try { + for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) { + const itemPath = _c.value; + result.push(itemPath); + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); + } + finally { if (e_1) throw e_1.error; } + } + return result; + }); + } + globGenerator() { + return __asyncGenerator(this, arguments, function* globGenerator_1() { + // Fill in defaults options + const options = globOptionsHelper.getOptions(this.options); + // Implicit descendants? + const patterns = []; + for (const pattern of this.patterns) { + patterns.push(pattern); + if (options.implicitDescendants && + (pattern.trailingSeparator || + pattern.segments[pattern.segments.length - 1] !== '**')) { + patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**'))); + } + } + // Push the search paths + const stack = []; + for (const searchPath of patternHelper.getSearchPaths(patterns)) { + core.debug(`Search path '${searchPath}'`); + // Exists? + try { + // Intentionally using lstat. Detection for broken symlink + // will be performed later (if following symlinks). + yield __await(fs.promises.lstat(searchPath)); + } + catch (err) { + if (err.code === 'ENOENT') { + continue; + } + throw err; + } + stack.unshift(new internal_search_state_1.SearchState(searchPath, 1)); + } + // Search + const traversalChain = []; // used to detect cycles + while (stack.length) { + // Pop + const item = stack.pop(); + // Match? + const match = patternHelper.match(patterns, item.path); + const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path); + if (!match && !partialMatch) { + continue; + } + // Stat + const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain) + // Broken symlink, or symlink cycle detected, or no longer exists + ); + // Broken symlink, or symlink cycle detected, or no longer exists + if (!stats) { + continue; + } + // Directory + if (stats.isDirectory()) { + // Matched + if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) { + yield yield __await(item.path); + } + // Descend? + else if (!partialMatch) { + continue; + } + // Push the child items in reverse + const childLevel = item.level + 1; + const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel)); + stack.push(...childItems.reverse()); + } + // File + else if (match & internal_match_kind_1.MatchKind.File) { + yield yield __await(item.path); + } + } + }); + } + /** + * Constructs a DefaultGlobber + */ + static create(patterns, options) { + return __awaiter(this, void 0, void 0, function* () { + const result = new DefaultGlobber(options); + if (IS_WINDOWS) { + patterns = patterns.replace(/\r\n/g, '\n'); + patterns = patterns.replace(/\r/g, '\n'); + } + const lines = patterns.split('\n').map(x => x.trim()); + for (const line of lines) { + // Empty or comment + if (!line || line.startsWith('#')) { + continue; + } + // Pattern + else { + result.patterns.push(new internal_pattern_1.Pattern(line)); + } + } + result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns)); + return result; + }); + } + static stat(item, options, traversalChain) { + return __awaiter(this, void 0, void 0, function* () { + // Note: + // `stat` returns info about the target of a symlink (or symlink chain) + // `lstat` returns info about a symlink itself + let stats; + if (options.followSymbolicLinks) { + try { + // Use `stat` (following symlinks) + stats = yield fs.promises.stat(item.path); + } + catch (err) { + if (err.code === 'ENOENT') { + if (options.omitBrokenSymbolicLinks) { + core.debug(`Broken symlink '${item.path}'`); + return undefined; + } + throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`); + } + throw err; + } + } + else { + // Use `lstat` (not following symlinks) + stats = yield fs.promises.lstat(item.path); + } + // Note, isDirectory() returns false for the lstat of a symlink + if (stats.isDirectory() && options.followSymbolicLinks) { + // Get the realpath + const realPath = yield fs.promises.realpath(item.path); + // Fixup the traversal chain to match the item level + while (traversalChain.length >= item.level) { + traversalChain.pop(); + } + // Test for a cycle + if (traversalChain.some((x) => x === realPath)) { + core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`); + return undefined; + } + // Update the traversal chain + traversalChain.push(realPath); + } + return stats; + }); + } +} +exports.DefaultGlobber = DefaultGlobber; +//# sourceMappingURL=internal-globber.js.map + +/***/ }), + +/***/ 2448: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.hashFiles = void 0; +const crypto = __importStar(__nccwpck_require__(6113)); +const core = __importStar(__nccwpck_require__(42186)); +const fs = __importStar(__nccwpck_require__(57147)); +const stream = __importStar(__nccwpck_require__(12781)); +const util = __importStar(__nccwpck_require__(73837)); +const path = __importStar(__nccwpck_require__(71017)); +function hashFiles(globber, verbose = false) { + var e_1, _a; + var _b; + return __awaiter(this, void 0, void 0, function* () { + const writeDelegate = verbose ? core.info : core.debug; + let hasMatch = false; + const githubWorkspace = (_b = process.env['GITHUB_WORKSPACE']) !== null && _b !== void 0 ? _b : process.cwd(); + const result = crypto.createHash('sha256'); + let count = 0; + try { + for (var _c = __asyncValues(globber.globGenerator()), _d; _d = yield _c.next(), !_d.done;) { + const file = _d.value; + writeDelegate(file); + if (!file.startsWith(`${githubWorkspace}${path.sep}`)) { + writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`); + continue; + } + if (fs.statSync(file).isDirectory()) { + writeDelegate(`Skip directory '${file}'.`); + continue; + } + const hash = crypto.createHash('sha256'); + const pipeline = util.promisify(stream.pipeline); + yield pipeline(fs.createReadStream(file), hash); + result.write(hash.digest()); + count++; + if (!hasMatch) { + hasMatch = true; + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (_d && !_d.done && (_a = _c.return)) yield _a.call(_c); + } + finally { if (e_1) throw e_1.error; } + } + result.end(); + if (hasMatch) { + writeDelegate(`Found ${count} files to hash.`); + return result.digest('hex'); + } + else { + writeDelegate(`No matches found for glob`); + return ''; + } + }); +} +exports.hashFiles = hashFiles; +//# sourceMappingURL=internal-hash-files.js.map + +/***/ }), + +/***/ 81063: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MatchKind = void 0; +/** + * Indicates whether a pattern matches a path + */ +var MatchKind; +(function (MatchKind) { + /** Not matched */ + MatchKind[MatchKind["None"] = 0] = "None"; + /** Matched if the path is a directory */ + MatchKind[MatchKind["Directory"] = 1] = "Directory"; + /** Matched if the path is a regular file */ + MatchKind[MatchKind["File"] = 2] = "File"; + /** Matched */ + MatchKind[MatchKind["All"] = 3] = "All"; +})(MatchKind = exports.MatchKind || (exports.MatchKind = {})); +//# sourceMappingURL=internal-match-kind.js.map + +/***/ }), + +/***/ 1849: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = void 0; +const path = __importStar(__nccwpck_require__(71017)); +const assert_1 = __importDefault(__nccwpck_require__(39491)); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths. + * + * For example, on Linux/macOS: + * - `/ => /` + * - `/hello => /` + * + * For example, on Windows: + * - `C:\ => C:\` + * - `C:\hello => C:\` + * - `C: => C:` + * - `C:hello => C:` + * - `\ => \` + * - `\hello => \` + * - `\\hello => \\hello` + * - `\\hello\world => \\hello\world` + */ +function dirname(p) { + // Normalize slashes and trim unnecessary trailing slash + p = safeTrimTrailingSeparator(p); + // Windows UNC root, e.g. \\hello or \\hello\world + if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { + return p; + } + // Get dirname + let result = path.dirname(p); + // Trim trailing slash for Windows UNC root, e.g. \\hello\world\ + if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { + result = safeTrimTrailingSeparator(result); + } + return result; +} +exports.dirname = dirname; +/** + * Roots the path if not already rooted. On Windows, relative roots like `\` + * or `C:` are expanded based on the current working directory. + */ +function ensureAbsoluteRoot(root, itemPath) { + assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`); + assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`); + // Already rooted + if (hasAbsoluteRoot(itemPath)) { + return itemPath; + } + // Windows + if (IS_WINDOWS) { + // Check for itemPath like C: or C:foo + if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) { + let cwd = process.cwd(); + assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); + // Drive letter matches cwd? Expand to cwd + if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) { + // Drive only, e.g. C: + if (itemPath.length === 2) { + // Preserve specified drive letter case (upper or lower) + return `${itemPath[0]}:\\${cwd.substr(3)}`; + } + // Drive + path, e.g. C:foo + else { + if (!cwd.endsWith('\\')) { + cwd += '\\'; + } + // Preserve specified drive letter case (upper or lower) + return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`; + } + } + // Different drive + else { + return `${itemPath[0]}:\\${itemPath.substr(2)}`; + } + } + // Check for itemPath like \ or \foo + else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) { + const cwd = process.cwd(); + assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); + return `${cwd[0]}:\\${itemPath.substr(1)}`; + } + } + assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`); + // Otherwise ensure root ends with a separator + if (root.endsWith('/') || (IS_WINDOWS && root.endsWith('\\'))) { + // Intentionally empty + } + else { + // Append separator + root += path.sep; + } + return root + itemPath; +} +exports.ensureAbsoluteRoot = ensureAbsoluteRoot; +/** + * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: + * `\\hello\share` and `C:\hello` (and using alternate separator). + */ +function hasAbsoluteRoot(itemPath) { + assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`); + // Normalize separators + itemPath = normalizeSeparators(itemPath); + // Windows + if (IS_WINDOWS) { + // E.g. \\hello\share or C:\hello + return itemPath.startsWith('\\\\') || /^[A-Z]:\\/i.test(itemPath); + } + // E.g. /hello + return itemPath.startsWith('/'); +} +exports.hasAbsoluteRoot = hasAbsoluteRoot; +/** + * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: + * `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator). + */ +function hasRoot(itemPath) { + assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`); + // Normalize separators + itemPath = normalizeSeparators(itemPath); + // Windows + if (IS_WINDOWS) { + // E.g. \ or \hello or \\hello + // E.g. C: or C:\hello + return itemPath.startsWith('\\') || /^[A-Z]:/i.test(itemPath); + } + // E.g. /hello + return itemPath.startsWith('/'); +} +exports.hasRoot = hasRoot; +/** + * Removes redundant slashes and converts `/` to `\` on Windows + */ +function normalizeSeparators(p) { + p = p || ''; + // Windows + if (IS_WINDOWS) { + // Convert slashes on Windows + p = p.replace(/\//g, '\\'); + // Remove redundant slashes + const isUnc = /^\\\\+[^\\]/.test(p); // e.g. \\hello + return (isUnc ? '\\' : '') + p.replace(/\\\\+/g, '\\'); // preserve leading \\ for UNC + } + // Remove redundant slashes + return p.replace(/\/\/+/g, '/'); +} +exports.normalizeSeparators = normalizeSeparators; +/** + * Normalizes the path separators and trims the trailing separator (when safe). + * For example, `/foo/ => /foo` but `/ => /` + */ +function safeTrimTrailingSeparator(p) { + // Short-circuit if empty + if (!p) { + return ''; + } + // Normalize separators + p = normalizeSeparators(p); + // No trailing slash + if (!p.endsWith(path.sep)) { + return p; + } + // Check '/' on Linux/macOS and '\' on Windows + if (p === path.sep) { + return p; + } + // On Windows check if drive root. E.g. C:\ + if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) { + return p; + } + // Otherwise trim trailing slash + return p.substr(0, p.length - 1); +} +exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator; +//# sourceMappingURL=internal-path-helper.js.map + +/***/ }), + +/***/ 96836: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Path = void 0; +const path = __importStar(__nccwpck_require__(71017)); +const pathHelper = __importStar(__nccwpck_require__(1849)); +const assert_1 = __importDefault(__nccwpck_require__(39491)); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Helper class for parsing paths into segments + */ +class Path { + /** + * Constructs a Path + * @param itemPath Path or array of segments + */ + constructor(itemPath) { + this.segments = []; + // String + if (typeof itemPath === 'string') { + assert_1.default(itemPath, `Parameter 'itemPath' must not be empty`); + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + // Not rooted + if (!pathHelper.hasRoot(itemPath)) { + this.segments = itemPath.split(path.sep); + } + // Rooted + else { + // Add all segments, while not at the root + let remaining = itemPath; + let dir = pathHelper.dirname(remaining); + while (dir !== remaining) { + // Add the segment + const basename = path.basename(remaining); + this.segments.unshift(basename); + // Truncate the last segment + remaining = dir; + dir = pathHelper.dirname(remaining); + } + // Remainder is the root + this.segments.unshift(remaining); + } + } + // Array + else { + // Must not be empty + assert_1.default(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`); + // Each segment + for (let i = 0; i < itemPath.length; i++) { + let segment = itemPath[i]; + // Must not be empty + assert_1.default(segment, `Parameter 'itemPath' must not contain any empty segments`); + // Normalize slashes + segment = pathHelper.normalizeSeparators(itemPath[i]); + // Root segment + if (i === 0 && pathHelper.hasRoot(segment)) { + segment = pathHelper.safeTrimTrailingSeparator(segment); + assert_1.default(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`); + this.segments.push(segment); + } + // All other segments + else { + // Must not contain slash + assert_1.default(!segment.includes(path.sep), `Parameter 'itemPath' contains unexpected path separators`); + this.segments.push(segment); + } + } + } + } + /** + * Converts the path to it's string representation + */ + toString() { + // First segment + let result = this.segments[0]; + // All others + let skipSlash = result.endsWith(path.sep) || (IS_WINDOWS && /^[A-Z]:$/i.test(result)); + for (let i = 1; i < this.segments.length; i++) { + if (skipSlash) { + skipSlash = false; + } + else { + result += path.sep; + } + result += this.segments[i]; + } + return result; + } +} +exports.Path = Path; +//# sourceMappingURL=internal-path.js.map + +/***/ }), + +/***/ 29005: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.partialMatch = exports.match = exports.getSearchPaths = void 0; +const pathHelper = __importStar(__nccwpck_require__(1849)); +const internal_match_kind_1 = __nccwpck_require__(81063); +const IS_WINDOWS = process.platform === 'win32'; +/** + * Given an array of patterns, returns an array of paths to search. + * Duplicates and paths under other included paths are filtered out. + */ +function getSearchPaths(patterns) { + // Ignore negate patterns + patterns = patterns.filter(x => !x.negate); + // Create a map of all search paths + const searchPathMap = {}; + for (const pattern of patterns) { + const key = IS_WINDOWS + ? pattern.searchPath.toUpperCase() + : pattern.searchPath; + searchPathMap[key] = 'candidate'; + } + const result = []; + for (const pattern of patterns) { + // Check if already included + const key = IS_WINDOWS + ? pattern.searchPath.toUpperCase() + : pattern.searchPath; + if (searchPathMap[key] === 'included') { + continue; + } + // Check for an ancestor search path + let foundAncestor = false; + let tempKey = key; + let parent = pathHelper.dirname(tempKey); + while (parent !== tempKey) { + if (searchPathMap[parent]) { + foundAncestor = true; + break; + } + tempKey = parent; + parent = pathHelper.dirname(tempKey); + } + // Include the search pattern in the result + if (!foundAncestor) { + result.push(pattern.searchPath); + searchPathMap[key] = 'included'; + } + } + return result; +} +exports.getSearchPaths = getSearchPaths; +/** + * Matches the patterns against the path + */ +function match(patterns, itemPath) { + let result = internal_match_kind_1.MatchKind.None; + for (const pattern of patterns) { + if (pattern.negate) { + result &= ~pattern.match(itemPath); + } + else { + result |= pattern.match(itemPath); + } + } + return result; +} +exports.match = match; +/** + * Checks whether to descend further into the directory + */ +function partialMatch(patterns, itemPath) { + return patterns.some(x => !x.negate && x.partialMatch(itemPath)); +} +exports.partialMatch = partialMatch; +//# sourceMappingURL=internal-pattern-helper.js.map + +/***/ }), + +/***/ 64536: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Pattern = void 0; +const os = __importStar(__nccwpck_require__(22037)); +const path = __importStar(__nccwpck_require__(71017)); +const pathHelper = __importStar(__nccwpck_require__(1849)); +const assert_1 = __importDefault(__nccwpck_require__(39491)); +const minimatch_1 = __nccwpck_require__(83973); +const internal_match_kind_1 = __nccwpck_require__(81063); +const internal_path_1 = __nccwpck_require__(96836); +const IS_WINDOWS = process.platform === 'win32'; +class Pattern { + constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) { + /** + * Indicates whether matches should be excluded from the result set + */ + this.negate = false; + // Pattern overload + let pattern; + if (typeof patternOrNegate === 'string') { + pattern = patternOrNegate.trim(); + } + // Segments overload + else { + // Convert to pattern + segments = segments || []; + assert_1.default(segments.length, `Parameter 'segments' must not empty`); + const root = Pattern.getLiteral(segments[0]); + assert_1.default(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`); + pattern = new internal_path_1.Path(segments).toString().trim(); + if (patternOrNegate) { + pattern = `!${pattern}`; + } + } + // Negate + while (pattern.startsWith('!')) { + this.negate = !this.negate; + pattern = pattern.substr(1).trim(); + } + // Normalize slashes and ensures absolute root + pattern = Pattern.fixupPattern(pattern, homedir); + // Segments + this.segments = new internal_path_1.Path(pattern).segments; + // Trailing slash indicates the pattern should only match directories, not regular files + this.trailingSeparator = pathHelper + .normalizeSeparators(pattern) + .endsWith(path.sep); + pattern = pathHelper.safeTrimTrailingSeparator(pattern); + // Search path (literal path prior to the first glob segment) + let foundGlob = false; + const searchSegments = this.segments + .map(x => Pattern.getLiteral(x)) + .filter(x => !foundGlob && !(foundGlob = x === '')); + this.searchPath = new internal_path_1.Path(searchSegments).toString(); + // Root RegExp (required when determining partial match) + this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? 'i' : ''); + this.isImplicitPattern = isImplicitPattern; + // Create minimatch + const minimatchOptions = { + dot: true, + nobrace: true, + nocase: IS_WINDOWS, + nocomment: true, + noext: true, + nonegate: true + }; + pattern = IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern; + this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions); + } + /** + * Matches the pattern against the specified path + */ + match(itemPath) { + // Last segment is globstar? + if (this.segments[this.segments.length - 1] === '**') { + // Normalize slashes + itemPath = pathHelper.normalizeSeparators(itemPath); + // Append a trailing slash. Otherwise Minimatch will not match the directory immediately + // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns + // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk. + if (!itemPath.endsWith(path.sep) && this.isImplicitPattern === false) { + // Note, this is safe because the constructor ensures the pattern has an absolute root. + // For example, formats like C: and C:foo on Windows are resolved to an absolute root. + itemPath = `${itemPath}${path.sep}`; + } + } + else { + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + } + // Match + if (this.minimatch.match(itemPath)) { + return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All; + } + return internal_match_kind_1.MatchKind.None; + } + /** + * Indicates whether the pattern may match descendants of the specified path + */ + partialMatch(itemPath) { + // Normalize slashes and trim unnecessary trailing slash + itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); + // matchOne does not handle root path correctly + if (pathHelper.dirname(itemPath) === itemPath) { + return this.rootRegExp.test(itemPath); + } + return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true); + } + /** + * Escapes glob patterns within a path + */ + static globEscape(s) { + return (IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS + .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment + .replace(/\?/g, '[?]') // escape '?' + .replace(/\*/g, '[*]'); // escape '*' + } + /** + * Normalizes slashes and ensures absolute root + */ + static fixupPattern(pattern, homedir) { + // Empty + assert_1.default(pattern, 'pattern cannot be empty'); + // Must not contain `.` segment, unless first segment + // Must not contain `..` segment + const literalSegments = new internal_path_1.Path(pattern).segments.map(x => Pattern.getLiteral(x)); + assert_1.default(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`); + // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r + assert_1.default(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`); + // Normalize slashes + pattern = pathHelper.normalizeSeparators(pattern); + // Replace leading `.` segment + if (pattern === '.' || pattern.startsWith(`.${path.sep}`)) { + pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1); + } + // Replace leading `~` segment + else if (pattern === '~' || pattern.startsWith(`~${path.sep}`)) { + homedir = homedir || os.homedir(); + assert_1.default(homedir, 'Unable to determine HOME directory'); + assert_1.default(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`); + pattern = Pattern.globEscape(homedir) + pattern.substr(1); + } + // Replace relative drive root, e.g. pattern is C: or C:foo + else if (IS_WINDOWS && + (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) { + let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2)); + if (pattern.length > 2 && !root.endsWith('\\')) { + root += '\\'; + } + pattern = Pattern.globEscape(root) + pattern.substr(2); + } + // Replace relative root, e.g. pattern is \ or \foo + else if (IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) { + let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', '\\'); + if (!root.endsWith('\\')) { + root += '\\'; + } + pattern = Pattern.globEscape(root) + pattern.substr(1); + } + // Otherwise ensure absolute root + else { + pattern = pathHelper.ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern); + } + return pathHelper.normalizeSeparators(pattern); + } + /** + * Attempts to unescape a pattern segment to create a literal path segment. + * Otherwise returns empty string. + */ + static getLiteral(segment) { + let literal = ''; + for (let i = 0; i < segment.length; i++) { + const c = segment[i]; + // Escape + if (c === '\\' && !IS_WINDOWS && i + 1 < segment.length) { + literal += segment[++i]; + continue; + } + // Wildcard + else if (c === '*' || c === '?') { + return ''; + } + // Character set + else if (c === '[' && i + 1 < segment.length) { + let set = ''; + let closed = -1; + for (let i2 = i + 1; i2 < segment.length; i2++) { + const c2 = segment[i2]; + // Escape + if (c2 === '\\' && !IS_WINDOWS && i2 + 1 < segment.length) { + set += segment[++i2]; + continue; + } + // Closed + else if (c2 === ']') { + closed = i2; + break; + } + // Otherwise + else { + set += c2; + } + } + // Closed? + if (closed >= 0) { + // Cannot convert + if (set.length > 1) { + return ''; + } + // Convert to literal + if (set) { + literal += set; + i = closed; + continue; + } + } + // Otherwise fall thru + } + // Append + literal += c; + } + return literal; + } + /** + * Escapes regexp special characters + * https://javascript.info/regexp-escaping + */ + static regExpEscape(s) { + return s.replace(/[[\\^$.|?*+()]/g, '\\$&'); + } +} +exports.Pattern = Pattern; +//# sourceMappingURL=internal-pattern.js.map + +/***/ }), + +/***/ 89117: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.SearchState = void 0; +class SearchState { + constructor(path, level) { + this.path = path; + this.level = level; + } +} +exports.SearchState = SearchState; +//# sourceMappingURL=internal-search-state.js.map + +/***/ }), + +/***/ 35526: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = void 0; +class BasicCredentialHandler { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BasicCredentialHandler = BasicCredentialHandler; +class BearerCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BearerCredentialHandler = BearerCredentialHandler; +class PersonalAccessTokenCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; +//# sourceMappingURL=auth.js.map + +/***/ }), + +/***/ 96255: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +/* eslint-disable @typescript-eslint/no-explicit-any */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; +const http = __importStar(__nccwpck_require__(13685)); +const https = __importStar(__nccwpck_require__(95687)); +const pm = __importStar(__nccwpck_require__(19835)); +const tunnel = __importStar(__nccwpck_require__(74294)); +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + })); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && + HttpRedirectCodes.includes(response.message.statusCode) && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === 'https:' && + parsedUrl.protocol !== parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + yield response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || + !HttpResponseRetryCodes.includes(response.message.statusCode)) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } + else if (!res) { + // If `err` is not passed, then `res` must be passed. + reject(new Error('Unknown error')); + } + else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === 'string') { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(undefined, res); + }); + let socket; + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info.options.path}`)); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + })), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + // get the result from the body + function dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + })); + }); + } +} +exports.HttpClient = HttpClient; +const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 19835: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.checkBypass = exports.getProxyUrl = void 0; +function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === 'https:'; + if (checkBypass(reqUrl)) { + return undefined; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + return process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + })(); + if (proxyVar) { + return new URL(proxyVar); + } + else { + return undefined; + } +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (const upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperReqHosts.some(x => x === upperNoProxyItem)) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; +//# sourceMappingURL=proxy.js.map + +/***/ }), + +/***/ 9417: +/***/ ((module) => { + +"use strict"; + +module.exports = balanced; +function balanced(a, b, str) { + if (a instanceof RegExp) a = maybeMatch(a, str); + if (b instanceof RegExp) b = maybeMatch(b, str); + + var r = range(a, b, str); + + return r && { + start: r[0], + end: r[1], + pre: str.slice(0, r[0]), + body: str.slice(r[0] + a.length, r[1]), + post: str.slice(r[1] + b.length) + }; +} + +function maybeMatch(reg, str) { + var m = str.match(reg); + return m ? m[0] : null; +} + +balanced.range = range; +function range(a, b, str) { + var begs, beg, left, right, result; + var ai = str.indexOf(a); + var bi = str.indexOf(b, ai + 1); + var i = ai; + + if (ai >= 0 && bi > 0) { + begs = []; + left = str.length; + + while (i >= 0 && !result) { + if (i == ai) { + begs.push(i); + ai = str.indexOf(a, i + 1); + } else if (begs.length == 1) { + result = [ begs.pop(), bi ]; + } else { + beg = begs.pop(); + if (beg < left) { + left = beg; + right = bi; + } + + bi = str.indexOf(b, i + 1); + } + + i = ai < bi && ai >= 0 ? ai : bi; + } + + if (begs.length) { + result = [ left, right ]; + } + } + + return result; +} + + +/***/ }), + +/***/ 33717: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var concatMap = __nccwpck_require__(86891); +var balanced = __nccwpck_require__(9417); + +module.exports = expandTop; + +var escSlash = '\0SLASH'+Math.random()+'\0'; +var escOpen = '\0OPEN'+Math.random()+'\0'; +var escClose = '\0CLOSE'+Math.random()+'\0'; +var escComma = '\0COMMA'+Math.random()+'\0'; +var escPeriod = '\0PERIOD'+Math.random()+'\0'; + +function numeric(str) { + return parseInt(str, 10) == str + ? parseInt(str, 10) + : str.charCodeAt(0); +} + +function escapeBraces(str) { + return str.split('\\\\').join(escSlash) + .split('\\{').join(escOpen) + .split('\\}').join(escClose) + .split('\\,').join(escComma) + .split('\\.').join(escPeriod); +} + +function unescapeBraces(str) { + return str.split(escSlash).join('\\') + .split(escOpen).join('{') + .split(escClose).join('}') + .split(escComma).join(',') + .split(escPeriod).join('.'); +} + + +// Basically just str.split(","), but handling cases +// where we have nested braced sections, which should be +// treated as individual members, like {a,{b,c},d} +function parseCommaParts(str) { + if (!str) + return ['']; + + var parts = []; + var m = balanced('{', '}', str); + + if (!m) + return str.split(','); + + var pre = m.pre; + var body = m.body; + var post = m.post; + var p = pre.split(','); + + p[p.length-1] += '{' + body + '}'; + var postParts = parseCommaParts(post); + if (post.length) { + p[p.length-1] += postParts.shift(); + p.push.apply(p, postParts); + } + + parts.push.apply(parts, p); + + return parts; +} + +function expandTop(str) { + if (!str) + return []; + + // I don't know why Bash 4.3 does this, but it does. + // Anything starting with {} will have the first two bytes preserved + // but *only* at the top level, so {},a}b will not expand to anything, + // but a{},b}c will be expanded to [a}c,abc]. + // One could argue that this is a bug in Bash, but since the goal of + // this module is to match Bash's rules, we escape a leading {} + if (str.substr(0, 2) === '{}') { + str = '\\{\\}' + str.substr(2); + } + + return expand(escapeBraces(str), true).map(unescapeBraces); +} + +function identity(e) { + return e; +} + +function embrace(str) { + return '{' + str + '}'; +} +function isPadded(el) { + return /^-?0\d/.test(el); +} + +function lte(i, y) { + return i <= y; +} +function gte(i, y) { + return i >= y; +} + +function expand(str, isTop) { + var expansions = []; + + var m = balanced('{', '}', str); + if (!m || /\$$/.test(m.pre)) return [str]; + + var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); + var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); + var isSequence = isNumericSequence || isAlphaSequence; + var isOptions = m.body.indexOf(',') >= 0; + if (!isSequence && !isOptions) { + // {a},b} + if (m.post.match(/,.*\}/)) { + str = m.pre + '{' + m.body + escClose + m.post; + return expand(str); + } + return [str]; + } + + var n; + if (isSequence) { + n = m.body.split(/\.\./); + } else { + n = parseCommaParts(m.body); + if (n.length === 1) { + // x{{a,b}}y ==> x{a}y x{b}y + n = expand(n[0], false).map(embrace); + if (n.length === 1) { + var post = m.post.length + ? expand(m.post, false) + : ['']; + return post.map(function(p) { + return m.pre + n[0] + p; + }); + } + } + } + + // at this point, n is the parts, and we know it's not a comma set + // with a single entry. + + // no need to expand pre, since it is guaranteed to be free of brace-sets + var pre = m.pre; + var post = m.post.length + ? expand(m.post, false) + : ['']; + + var N; + + if (isSequence) { + var x = numeric(n[0]); + var y = numeric(n[1]); + var width = Math.max(n[0].length, n[1].length) + var incr = n.length == 3 + ? Math.abs(numeric(n[2])) + : 1; + var test = lte; + var reverse = y < x; + if (reverse) { + incr *= -1; + test = gte; + } + var pad = n.some(isPadded); + + N = []; + + for (var i = x; test(i, y); i += incr) { + var c; + if (isAlphaSequence) { + c = String.fromCharCode(i); + if (c === '\\') + c = ''; + } else { + c = String(i); + if (pad) { + var need = width - c.length; + if (need > 0) { + var z = new Array(need + 1).join('0'); + if (i < 0) + c = '-' + z + c.slice(1); + else + c = z + c; + } + } + } + N.push(c); + } + } else { + N = concatMap(n, function(el) { return expand(el, false) }); + } + + for (var j = 0; j < N.length; j++) { + for (var k = 0; k < post.length; k++) { + var expansion = pre + N[j] + post[k]; + if (!isTop || isSequence || expansion) + expansions.push(expansion); + } + } + + return expansions; +} + + + +/***/ }), + +/***/ 86891: +/***/ ((module) => { + +module.exports = function (xs, fn) { + var res = []; + for (var i = 0; i < xs.length; i++) { + var x = fn(xs[i], i); + if (isArray(x)) res.push.apply(res, x); + else res.push(x); + } + return res; +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + + +/***/ }), + +/***/ 83973: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = minimatch +minimatch.Minimatch = Minimatch + +var path = (function () { try { return __nccwpck_require__(71017) } catch (e) {}}()) || { + sep: '/' +} +minimatch.sep = path.sep + +var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} +var expand = __nccwpck_require__(33717) + +var plTypes = { + '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, + '?': { open: '(?:', close: ')?' }, + '+': { open: '(?:', close: ')+' }, + '*': { open: '(?:', close: ')*' }, + '@': { open: '(?:', close: ')' } +} + +// any single thing other than / +// don't need to escape / when using new RegExp() +var qmark = '[^/]' + +// * => any number of characters +var star = qmark + '*?' + +// ** when dots are allowed. Anything goes, except .. and . +// not (^ or / followed by one or two dots followed by $ or /), +// followed by anything, any number of times. +var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' + +// not a ^ or / followed by a dot, +// followed by anything, any number of times. +var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' + +// characters that need to be escaped in RegExp. +var reSpecials = charSet('().*{}+?[]^$\\!') + +// "abc" -> { a:true, b:true, c:true } +function charSet (s) { + return s.split('').reduce(function (set, c) { + set[c] = true + return set + }, {}) +} + +// normalizes slashes. +var slashSplit = /\/+/ + +minimatch.filter = filter +function filter (pattern, options) { + options = options || {} + return function (p, i, list) { + return minimatch(p, pattern, options) + } +} + +function ext (a, b) { + b = b || {} + var t = {} + Object.keys(a).forEach(function (k) { + t[k] = a[k] + }) + Object.keys(b).forEach(function (k) { + t[k] = b[k] + }) + return t +} + +minimatch.defaults = function (def) { + if (!def || typeof def !== 'object' || !Object.keys(def).length) { + return minimatch + } + + var orig = minimatch + + var m = function minimatch (p, pattern, options) { + return orig(p, pattern, ext(def, options)) + } + + m.Minimatch = function Minimatch (pattern, options) { + return new orig.Minimatch(pattern, ext(def, options)) + } + m.Minimatch.defaults = function defaults (options) { + return orig.defaults(ext(def, options)).Minimatch + } + + m.filter = function filter (pattern, options) { + return orig.filter(pattern, ext(def, options)) + } + + m.defaults = function defaults (options) { + return orig.defaults(ext(def, options)) + } + + m.makeRe = function makeRe (pattern, options) { + return orig.makeRe(pattern, ext(def, options)) + } + + m.braceExpand = function braceExpand (pattern, options) { + return orig.braceExpand(pattern, ext(def, options)) + } + + m.match = function (list, pattern, options) { + return orig.match(list, pattern, ext(def, options)) + } + + return m +} + +Minimatch.defaults = function (def) { + return minimatch.defaults(def).Minimatch +} + +function minimatch (p, pattern, options) { + assertValidPattern(pattern) + + if (!options) options = {} + + // shortcut: comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + return false + } + + return new Minimatch(pattern, options).match(p) +} + +function Minimatch (pattern, options) { + if (!(this instanceof Minimatch)) { + return new Minimatch(pattern, options) + } + + assertValidPattern(pattern) + + if (!options) options = {} + + pattern = pattern.trim() + + // windows support: need to use /, not \ + if (!options.allowWindowsEscape && path.sep !== '/') { + pattern = pattern.split(path.sep).join('/') + } + + this.options = options + this.set = [] + this.pattern = pattern + this.regexp = null + this.negate = false + this.comment = false + this.empty = false + this.partial = !!options.partial + + // make the set of regexps etc. + this.make() +} + +Minimatch.prototype.debug = function () {} + +Minimatch.prototype.make = make +function make () { + var pattern = this.pattern + var options = this.options + + // empty patterns and comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + this.comment = true + return + } + if (!pattern) { + this.empty = true + return + } + + // step 1: figure out negation, etc. + this.parseNegate() + + // step 2: expand braces + var set = this.globSet = this.braceExpand() + + if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) } + + this.debug(this.pattern, set) + + // step 3: now we have a set, so turn each one into a series of path-portion + // matching patterns. + // These will be regexps, except in the case of "**", which is + // set to the GLOBSTAR object for globstar behavior, + // and will not contain any / characters + set = this.globParts = set.map(function (s) { + return s.split(slashSplit) + }) + + this.debug(this.pattern, set) + + // glob --> regexps + set = set.map(function (s, si, set) { + return s.map(this.parse, this) + }, this) + + this.debug(this.pattern, set) + + // filter out everything that didn't compile properly. + set = set.filter(function (s) { + return s.indexOf(false) === -1 + }) + + this.debug(this.pattern, set) + + this.set = set +} + +Minimatch.prototype.parseNegate = parseNegate +function parseNegate () { + var pattern = this.pattern + var negate = false + var options = this.options + var negateOffset = 0 + + if (options.nonegate) return + + for (var i = 0, l = pattern.length + ; i < l && pattern.charAt(i) === '!' + ; i++) { + negate = !negate + negateOffset++ + } + + if (negateOffset) this.pattern = pattern.substr(negateOffset) + this.negate = negate +} + +// Brace expansion: +// a{b,c}d -> abd acd +// a{b,}c -> abc ac +// a{0..3}d -> a0d a1d a2d a3d +// a{b,c{d,e}f}g -> abg acdfg acefg +// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg +// +// Invalid sets are not expanded. +// a{2..}b -> a{2..}b +// a{b}c -> a{b}c +minimatch.braceExpand = function (pattern, options) { + return braceExpand(pattern, options) +} + +Minimatch.prototype.braceExpand = braceExpand + +function braceExpand (pattern, options) { + if (!options) { + if (this instanceof Minimatch) { + options = this.options + } else { + options = {} + } + } + + pattern = typeof pattern === 'undefined' + ? this.pattern : pattern + + assertValidPattern(pattern) + + // Thanks to Yeting Li for + // improving this regexp to avoid a ReDOS vulnerability. + if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) { + // shortcut. no need to expand. + return [pattern] + } + + return expand(pattern) +} + +var MAX_PATTERN_LENGTH = 1024 * 64 +var assertValidPattern = function (pattern) { + if (typeof pattern !== 'string') { + throw new TypeError('invalid pattern') + } + + if (pattern.length > MAX_PATTERN_LENGTH) { + throw new TypeError('pattern is too long') + } +} + +// parse a component of the expanded set. +// At this point, no pattern may contain "/" in it +// so we're going to return a 2d array, where each entry is the full +// pattern, split on '/', and then turned into a regular expression. +// A regexp is made at the end which joins each array with an +// escaped /, and another full one which joins each regexp with |. +// +// Following the lead of Bash 4.1, note that "**" only has special meaning +// when it is the *only* thing in a path portion. Otherwise, any series +// of * is equivalent to a single *. Globstar behavior is enabled by +// default, and can be disabled by setting options.noglobstar. +Minimatch.prototype.parse = parse +var SUBPARSE = {} +function parse (pattern, isSub) { + assertValidPattern(pattern) + + var options = this.options + + // shortcuts + if (pattern === '**') { + if (!options.noglobstar) + return GLOBSTAR + else + pattern = '*' + } + if (pattern === '') return '' + + var re = '' + var hasMagic = !!options.nocase + var escaping = false + // ? => one single character + var patternListStack = [] + var negativeLists = [] + var stateChar + var inClass = false + var reClassStart = -1 + var classStart = -1 + // . and .. never match anything that doesn't start with ., + // even when options.dot is set. + var patternStart = pattern.charAt(0) === '.' ? '' // anything + // not (start or / followed by . or .. followed by / or end) + : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' + : '(?!\\.)' + var self = this + + function clearStateChar () { + if (stateChar) { + // we had some state-tracking character + // that wasn't consumed by this pass. + switch (stateChar) { + case '*': + re += star + hasMagic = true + break + case '?': + re += qmark + hasMagic = true + break + default: + re += '\\' + stateChar + break + } + self.debug('clearStateChar %j %j', stateChar, re) + stateChar = false + } + } + + for (var i = 0, len = pattern.length, c + ; (i < len) && (c = pattern.charAt(i)) + ; i++) { + this.debug('%s\t%s %s %j', pattern, i, re, c) + + // skip over any that are escaped. + if (escaping && reSpecials[c]) { + re += '\\' + c + escaping = false + continue + } + + switch (c) { + /* istanbul ignore next */ + case '/': { + // completely not allowed, even escaped. + // Should already be path-split by now. + return false + } + + case '\\': + clearStateChar() + escaping = true + continue + + // the various stateChar values + // for the "extglob" stuff. + case '?': + case '*': + case '+': + case '@': + case '!': + this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) + + // all of those are literals inside a class, except that + // the glob [!a] means [^a] in regexp + if (inClass) { + this.debug(' in class') + if (c === '!' && i === classStart + 1) c = '^' + re += c + continue + } + + // if we already have a stateChar, then it means + // that there was something like ** or +? in there. + // Handle the stateChar, then proceed with this one. + self.debug('call clearStateChar %j', stateChar) + clearStateChar() + stateChar = c + // if extglob is disabled, then +(asdf|foo) isn't a thing. + // just clear the statechar *now*, rather than even diving into + // the patternList stuff. + if (options.noext) clearStateChar() + continue + + case '(': + if (inClass) { + re += '(' + continue + } + + if (!stateChar) { + re += '\\(' + continue + } + + patternListStack.push({ + type: stateChar, + start: i - 1, + reStart: re.length, + open: plTypes[stateChar].open, + close: plTypes[stateChar].close + }) + // negation is (?:(?!js)[^/]*) + re += stateChar === '!' ? '(?:(?!(?:' : '(?:' + this.debug('plType %j %j', stateChar, re) + stateChar = false + continue + + case ')': + if (inClass || !patternListStack.length) { + re += '\\)' + continue + } + + clearStateChar() + hasMagic = true + var pl = patternListStack.pop() + // negation is (?:(?!js)[^/]*) + // The others are (?:) + re += pl.close + if (pl.type === '!') { + negativeLists.push(pl) + } + pl.reEnd = re.length + continue + + case '|': + if (inClass || !patternListStack.length || escaping) { + re += '\\|' + escaping = false + continue + } + + clearStateChar() + re += '|' + continue + + // these are mostly the same in regexp and glob + case '[': + // swallow any state-tracking char before the [ + clearStateChar() + + if (inClass) { + re += '\\' + c + continue + } + + inClass = true + classStart = i + reClassStart = re.length + re += c + continue + + case ']': + // a right bracket shall lose its special + // meaning and represent itself in + // a bracket expression if it occurs + // first in the list. -- POSIX.2 2.8.3.2 + if (i === classStart + 1 || !inClass) { + re += '\\' + c + escaping = false + continue + } + + // handle the case where we left a class open. + // "[z-a]" is valid, equivalent to "\[z-a\]" + // split where the last [ was, make sure we don't have + // an invalid re. if so, re-walk the contents of the + // would-be class to re-translate any characters that + // were passed through as-is + // TODO: It would probably be faster to determine this + // without a try/catch and a new RegExp, but it's tricky + // to do safely. For now, this is safe and works. + var cs = pattern.substring(classStart + 1, i) + try { + RegExp('[' + cs + ']') + } catch (er) { + // not a valid class! + var sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' + hasMagic = hasMagic || sp[1] + inClass = false + continue + } + + // finish up the class. + hasMagic = true + inClass = false + re += c + continue + + default: + // swallow any state char that wasn't consumed + clearStateChar() + + if (escaping) { + // no need + escaping = false + } else if (reSpecials[c] + && !(c === '^' && inClass)) { + re += '\\' + } + + re += c + + } // switch + } // for + + // handle the case where we left a class open. + // "[abc" is valid, equivalent to "\[abc" + if (inClass) { + // split where the last [ was, and escape it + // this is a huge pita. We now have to re-walk + // the contents of the would-be class to re-translate + // any characters that were passed through as-is + cs = pattern.substr(classStart + 1) + sp = this.parse(cs, SUBPARSE) + re = re.substr(0, reClassStart) + '\\[' + sp[0] + hasMagic = hasMagic || sp[1] + } + + // handle the case where we had a +( thing at the *end* + // of the pattern. + // each pattern list stack adds 3 chars, and we need to go through + // and escape any | chars that were passed through as-is for the regexp. + // Go through and escape them, taking care not to double-escape any + // | chars that were already escaped. + for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { + var tail = re.slice(pl.reStart + pl.open.length) + this.debug('setting tail', re, pl) + // maybe some even number of \, then maybe 1 \, followed by a | + tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { + if (!$2) { + // the | isn't already escaped, so escape it. + $2 = '\\' + } + + // need to escape all those slashes *again*, without escaping the + // one that we need for escaping the | character. As it works out, + // escaping an even number of slashes can be done by simply repeating + // it exactly after itself. That's why this trick works. + // + // I am sorry that you have to see this. + return $1 + $1 + $2 + '|' + }) + + this.debug('tail=%j\n %s', tail, tail, pl, re) + var t = pl.type === '*' ? star + : pl.type === '?' ? qmark + : '\\' + pl.type + + hasMagic = true + re = re.slice(0, pl.reStart) + t + '\\(' + tail + } + + // handle trailing things that only matter at the very end. + clearStateChar() + if (escaping) { + // trailing \\ + re += '\\\\' + } + + // only need to apply the nodot start if the re starts with + // something that could conceivably capture a dot + var addPatternStart = false + switch (re.charAt(0)) { + case '[': case '.': case '(': addPatternStart = true + } + + // Hack to work around lack of negative lookbehind in JS + // A pattern like: *.!(x).!(y|z) needs to ensure that a name + // like 'a.xyz.yz' doesn't match. So, the first negative + // lookahead, has to look ALL the way ahead, to the end of + // the pattern. + for (var n = negativeLists.length - 1; n > -1; n--) { + var nl = negativeLists[n] + + var nlBefore = re.slice(0, nl.reStart) + var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) + var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + var nlAfter = re.slice(nl.reEnd) + + nlLast += nlAfter + + // Handle nested stuff like *(*.js|!(*.json)), where open parens + // mean that we should *not* include the ) in the bit that is considered + // "after" the negated section. + var openParensBefore = nlBefore.split('(').length - 1 + var cleanAfter = nlAfter + for (i = 0; i < openParensBefore; i++) { + cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') + } + nlAfter = cleanAfter + + var dollar = '' + if (nlAfter === '' && isSub !== SUBPARSE) { + dollar = '$' + } + var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast + re = newRe + } + + // if the re is not "" at this point, then we need to make sure + // it doesn't match against an empty path part. + // Otherwise a/* will match a/, which it should not. + if (re !== '' && hasMagic) { + re = '(?=.)' + re + } + + if (addPatternStart) { + re = patternStart + re + } + + // parsing just a piece of a larger pattern. + if (isSub === SUBPARSE) { + return [re, hasMagic] + } + + // skip the regexp for non-magical patterns + // unescape anything in it, though, so that it'll be + // an exact match against a file etc. + if (!hasMagic) { + return globUnescape(pattern) + } + + var flags = options.nocase ? 'i' : '' + try { + var regExp = new RegExp('^' + re + '$', flags) + } catch (er) /* istanbul ignore next - should be impossible */ { + // If it was an invalid regular expression, then it can't match + // anything. This trick looks for a character after the end of + // the string, which is of course impossible, except in multi-line + // mode, but it's not a /m regex. + return new RegExp('$.') + } + + regExp._glob = pattern + regExp._src = re + + return regExp +} + +minimatch.makeRe = function (pattern, options) { + return new Minimatch(pattern, options || {}).makeRe() +} + +Minimatch.prototype.makeRe = makeRe +function makeRe () { + if (this.regexp || this.regexp === false) return this.regexp + + // at this point, this.set is a 2d array of partial + // pattern strings, or "**". + // + // It's better to use .match(). This function shouldn't + // be used, really, but it's pretty convenient sometimes, + // when you just want to work with a regex. + var set = this.set + + if (!set.length) { + this.regexp = false + return this.regexp + } + var options = this.options + + var twoStar = options.noglobstar ? star + : options.dot ? twoStarDot + : twoStarNoDot + var flags = options.nocase ? 'i' : '' + + var re = set.map(function (pattern) { + return pattern.map(function (p) { + return (p === GLOBSTAR) ? twoStar + : (typeof p === 'string') ? regExpEscape(p) + : p._src + }).join('\\\/') + }).join('|') + + // must match entire pattern + // ending in a * or ** will make it less strict. + re = '^(?:' + re + ')$' + + // can match anything, as long as it's not this. + if (this.negate) re = '^(?!' + re + ').*$' + + try { + this.regexp = new RegExp(re, flags) + } catch (ex) /* istanbul ignore next - should be impossible */ { + this.regexp = false + } + return this.regexp +} + +minimatch.match = function (list, pattern, options) { + options = options || {} + var mm = new Minimatch(pattern, options) + list = list.filter(function (f) { + return mm.match(f) + }) + if (mm.options.nonull && !list.length) { + list.push(pattern) + } + return list +} + +Minimatch.prototype.match = function match (f, partial) { + if (typeof partial === 'undefined') partial = this.partial + this.debug('match', f, this.pattern) + // short-circuit in the case of busted things. + // comments, etc. + if (this.comment) return false + if (this.empty) return f === '' + + if (f === '/' && partial) return true + + var options = this.options + + // windows: need to use /, not \ + if (path.sep !== '/') { + f = f.split(path.sep).join('/') + } + + // treat the test path as a set of pathparts. + f = f.split(slashSplit) + this.debug(this.pattern, 'split', f) + + // just ONE of the pattern sets in this.set needs to match + // in order for it to be valid. If negating, then just one + // match means that we have failed. + // Either way, return on the first hit. + + var set = this.set + this.debug(this.pattern, 'set', set) + + // Find the basename of the path by looking for the last non-empty segment + var filename + var i + for (i = f.length - 1; i >= 0; i--) { + filename = f[i] + if (filename) break + } + + for (i = 0; i < set.length; i++) { + var pattern = set[i] + var file = f + if (options.matchBase && pattern.length === 1) { + file = [filename] + } + var hit = this.matchOne(file, pattern, partial) + if (hit) { + if (options.flipNegate) return true + return !this.negate + } + } + + // didn't get any hits. this is success if it's a negative + // pattern, failure otherwise. + if (options.flipNegate) return false + return this.negate +} + +// set partial to true to test if, for example, +// "/a/b" matches the start of "/*/b/*/d" +// Partial means, if you run out of file before you run +// out of pattern, then that's fine, as long as all +// the parts match. +Minimatch.prototype.matchOne = function (file, pattern, partial) { + var options = this.options + + this.debug('matchOne', + { 'this': this, file: file, pattern: pattern }) + + this.debug('matchOne', file.length, pattern.length) + + for (var fi = 0, + pi = 0, + fl = file.length, + pl = pattern.length + ; (fi < fl) && (pi < pl) + ; fi++, pi++) { + this.debug('matchOne loop') + var p = pattern[pi] + var f = file[fi] + + this.debug(pattern, p, f) + + // should be impossible. + // some invalid regexp stuff in the set. + /* istanbul ignore if */ + if (p === false) return false + + if (p === GLOBSTAR) { + this.debug('GLOBSTAR', [pattern, p, f]) + + // "**" + // a/**/b/**/c would match the following: + // a/b/x/y/z/c + // a/x/y/z/b/c + // a/b/x/b/x/c + // a/b/c + // To do this, take the rest of the pattern after + // the **, and see if it would match the file remainder. + // If so, return success. + // If not, the ** "swallows" a segment, and try again. + // This is recursively awful. + // + // a/**/b/**/c matching a/b/x/y/z/c + // - a matches a + // - doublestar + // - matchOne(b/x/y/z/c, b/**/c) + // - b matches b + // - doublestar + // - matchOne(x/y/z/c, c) -> no + // - matchOne(y/z/c, c) -> no + // - matchOne(z/c, c) -> no + // - matchOne(c, c) yes, hit + var fr = fi + var pr = pi + 1 + if (pr === pl) { + this.debug('** at the end') + // a ** at the end will just swallow the rest. + // We have found a match. + // however, it will not swallow /.x, unless + // options.dot is set. + // . and .. are *never* matched by **, for explosively + // exponential reasons. + for (; fi < fl; fi++) { + if (file[fi] === '.' || file[fi] === '..' || + (!options.dot && file[fi].charAt(0) === '.')) return false + } + return true + } + + // ok, let's see if we can swallow whatever we can. + while (fr < fl) { + var swallowee = file[fr] + + this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) + + // XXX remove this slice. Just pass the start index. + if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { + this.debug('globstar found match!', fr, fl, swallowee) + // found a match. + return true + } else { + // can't swallow "." or ".." ever. + // can only swallow ".foo" when explicitly asked. + if (swallowee === '.' || swallowee === '..' || + (!options.dot && swallowee.charAt(0) === '.')) { + this.debug('dot detected!', file, fr, pattern, pr) + break + } + + // ** swallows a segment, and continue. + this.debug('globstar swallow a segment, and continue') + fr++ + } + } + + // no match was found. + // However, in partial mode, we can't say this is necessarily over. + // If there's more *pattern* left, then + /* istanbul ignore if */ + if (partial) { + // ran out of file + this.debug('\n>>> no match, partial?', file, fr, pattern, pr) + if (fr === fl) return true + } + return false + } + + // something other than ** + // non-magic patterns just have to match exactly + // patterns with magic have been turned into regexps. + var hit + if (typeof p === 'string') { + hit = f === p + this.debug('string match', p, f, hit) + } else { + hit = f.match(p) + this.debug('pattern match', p, f, hit) + } + + if (!hit) return false + } + + // Note: ending in / means that we'll get a final "" + // at the end of the pattern. This can only match a + // corresponding "" at the end of the file. + // If the file ends in /, then it can only match a + // a pattern that ends in /, unless the pattern just + // doesn't have any more for it. But, a/b/ should *not* + // match "a/b/*", even though "" matches against the + // [^/]*? pattern, except in partial mode, where it might + // simply not be reached yet. + // However, a/b/ should still satisfy a/* + + // now either we fell off the end of the pattern, or we're done. + if (fi === fl && pi === pl) { + // ran out of pattern and filename at the same time. + // an exact hit! + return true + } else if (fi === fl) { + // ran out of file, but still had pattern left. + // this is ok if we're doing the match as part of + // a glob fs traversal. + return partial + } else /* istanbul ignore else */ if (pi === pl) { + // ran out of pattern, still have file left. + // this is only acceptable if we're on the very last + // empty segment of a file with a trailing slash. + // a/* should match a/b/ + return (fi === fl - 1) && (file[fi] === '') + } + + // should be unreachable. + /* istanbul ignore next */ + throw new Error('wtf?') +} + +// replace stuff like \* with * +function globUnescape (s) { + return s.replace(/\\(.)/g, '$1') +} + +function regExpEscape (s) { + return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') +} + + +/***/ }), + +/***/ 74294: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = __nccwpck_require__(54219); + + +/***/ }), + +/***/ 54219: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +var net = __nccwpck_require__(41808); +var tls = __nccwpck_require__(24404); +var http = __nccwpck_require__(13685); +var https = __nccwpck_require__(95687); +var events = __nccwpck_require__(82361); +var assert = __nccwpck_require__(39491); +var util = __nccwpck_require__(73837); + + +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; + + +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} + +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} + +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + + +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); +} +util.inherits(TunnelingAgent, events.EventEmitter); + +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); + + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } + + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); + + function onFree() { + self.emit('free', socket, options); + } + + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); + } + }); +}; + +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false, + headers: { + host: options.host + ':' + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } + + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } + + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode !== 200) { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + socket.destroy(); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug('got illegal response body from proxy'); + socket.destroy(); + var error = new Error('got illegal response body from proxy'); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + + function onError(cause) { + connectReq.removeAllListeners(); + + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } +}; + +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + } +}; + +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); + + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); +} + + +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} + +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } + } + } + return target; +} + + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; + } else { + args.unshift('TUNNEL:'); + } + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test + + +/***/ }), + +/***/ 75840: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +Object.defineProperty(exports, "v1", ({ + enumerable: true, + get: function () { + return _v.default; + } +})); +Object.defineProperty(exports, "v3", ({ + enumerable: true, + get: function () { + return _v2.default; + } +})); +Object.defineProperty(exports, "v4", ({ + enumerable: true, + get: function () { + return _v3.default; + } +})); +Object.defineProperty(exports, "v5", ({ + enumerable: true, + get: function () { + return _v4.default; + } +})); +Object.defineProperty(exports, "NIL", ({ + enumerable: true, + get: function () { + return _nil.default; + } +})); +Object.defineProperty(exports, "version", ({ + enumerable: true, + get: function () { + return _version.default; + } +})); +Object.defineProperty(exports, "validate", ({ + enumerable: true, + get: function () { + return _validate.default; + } +})); +Object.defineProperty(exports, "stringify", ({ + enumerable: true, + get: function () { + return _stringify.default; + } +})); +Object.defineProperty(exports, "parse", ({ + enumerable: true, + get: function () { + return _parse.default; + } +})); + +var _v = _interopRequireDefault(__nccwpck_require__(78628)); + +var _v2 = _interopRequireDefault(__nccwpck_require__(86409)); + +var _v3 = _interopRequireDefault(__nccwpck_require__(85122)); + +var _v4 = _interopRequireDefault(__nccwpck_require__(79120)); + +var _nil = _interopRequireDefault(__nccwpck_require__(25332)); + +var _version = _interopRequireDefault(__nccwpck_require__(81595)); + +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); + +var _parse = _interopRequireDefault(__nccwpck_require__(62746)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/***/ }), + +/***/ 4569: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function md5(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('md5').update(bytes).digest(); +} + +var _default = md5; +exports["default"] = _default; + +/***/ }), + +/***/ 25332: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = '00000000-0000-0000-0000-000000000000'; +exports["default"] = _default; + +/***/ }), + +/***/ 62746: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function parse(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + let v; + const arr = new Uint8Array(16); // Parse ########-....-....-....-............ + + arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; + arr[1] = v >>> 16 & 0xff; + arr[2] = v >>> 8 & 0xff; + arr[3] = v & 0xff; // Parse ........-####-....-....-............ + + arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; + arr[5] = v & 0xff; // Parse ........-....-####-....-............ + + arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; + arr[7] = v & 0xff; // Parse ........-....-....-####-............ + + arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; + arr[9] = v & 0xff; // Parse ........-....-....-....-############ + // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) + + arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; + arr[11] = v / 0x100000000 & 0xff; + arr[12] = v >>> 24 & 0xff; + arr[13] = v >>> 16 & 0xff; + arr[14] = v >>> 8 & 0xff; + arr[15] = v & 0xff; + return arr; +} + +var _default = parse; +exports["default"] = _default; + +/***/ }), + +/***/ 40814: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; +exports["default"] = _default; + +/***/ }), + +/***/ 50807: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = rng; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate + +let poolPtr = rnds8Pool.length; + +function rng() { + if (poolPtr > rnds8Pool.length - 16) { + _crypto.default.randomFillSync(rnds8Pool); + + poolPtr = 0; + } + + return rnds8Pool.slice(poolPtr, poolPtr += 16); +} + +/***/ }), + +/***/ 85274: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function sha1(bytes) { + if (Array.isArray(bytes)) { + bytes = Buffer.from(bytes); + } else if (typeof bytes === 'string') { + bytes = Buffer.from(bytes, 'utf8'); + } + + return _crypto.default.createHash('sha1').update(bytes).digest(); +} + +var _default = sha1; +exports["default"] = _default; + +/***/ }), + +/***/ 18950: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ +const byteToHex = []; + +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 0x100).toString(16).substr(1)); +} + +function stringify(arr, offset = 0) { + // Note: Be careful editing this code! It's been tuned for performance + // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 + const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one + // of the following: + // - One or more input array values don't map to a hex octet (leading to + // "undefined" in the uuid) + // - Invalid input values for the RFC `version` or `variant` fields + + if (!(0, _validate.default)(uuid)) { + throw TypeError('Stringified UUID is invalid'); + } + + return uuid; +} + +var _default = stringify; +exports["default"] = _default; + +/***/ }), + +/***/ 78628: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(50807)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// **`v1()` - Generate time-based UUID** +// +// Inspired by https://github.com/LiosK/UUID.js +// and http://docs.python.org/library/uuid.html +let _nodeId; + +let _clockseq; // Previous uuid creation time + + +let _lastMSecs = 0; +let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details + +function v1(options, buf, offset) { + let i = buf && offset || 0; + const b = buf || new Array(16); + options = options || {}; + let node = options.node || _nodeId; + let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not + // specified. We do this lazily to minimize issues related to insufficient + // system entropy. See #189 + + if (node == null || clockseq == null) { + const seedBytes = options.random || (options.rng || _rng.default)(); + + if (node == null) { + // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) + node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; + } + + if (clockseq == null) { + // Per 4.2.2, randomize (14 bit) clockseq + clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; + } + } // UUID timestamps are 100 nano-second units since the Gregorian epoch, + // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so + // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' + // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. + + + let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock + // cycle to simulate higher resolution clock + + let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) + + const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression + + if (dt < 0 && options.clockseq === undefined) { + clockseq = clockseq + 1 & 0x3fff; + } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new + // time interval + + + if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { + nsecs = 0; + } // Per 4.2.1.2 Throw error if too many uuids are requested + + + if (nsecs >= 10000) { + throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); + } + + _lastMSecs = msecs; + _lastNSecs = nsecs; + _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch + + msecs += 12219292800000; // `time_low` + + const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; + b[i++] = tl >>> 24 & 0xff; + b[i++] = tl >>> 16 & 0xff; + b[i++] = tl >>> 8 & 0xff; + b[i++] = tl & 0xff; // `time_mid` + + const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; + b[i++] = tmh >>> 8 & 0xff; + b[i++] = tmh & 0xff; // `time_high_and_version` + + b[i++] = tmh >>> 24 & 0xf | 0x10; // include version + + b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) + + b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` + + b[i++] = clockseq & 0xff; // `node` + + for (let n = 0; n < 6; ++n) { + b[i + n] = node[n]; + } + + return buf || (0, _stringify.default)(b); +} + +var _default = v1; +exports["default"] = _default; + +/***/ }), + +/***/ 86409: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(65998)); + +var _md = _interopRequireDefault(__nccwpck_require__(4569)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v3 = (0, _v.default)('v3', 0x30, _md.default); +var _default = v3; +exports["default"] = _default; + +/***/ }), + +/***/ 65998: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = _default; +exports.URL = exports.DNS = void 0; + +var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); + +var _parse = _interopRequireDefault(__nccwpck_require__(62746)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); // UTF8 escape + + const bytes = []; + + for (let i = 0; i < str.length; ++i) { + bytes.push(str.charCodeAt(i)); + } + + return bytes; +} + +const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; +exports.DNS = DNS; +const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; +exports.URL = URL; + +function _default(name, version, hashfunc) { + function generateUUID(value, namespace, buf, offset) { + if (typeof value === 'string') { + value = stringToBytes(value); + } + + if (typeof namespace === 'string') { + namespace = (0, _parse.default)(namespace); + } + + if (namespace.length !== 16) { + throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); + } // Compute hash of namespace and value, Per 4.3 + // Future: Use spread syntax when supported on all platforms, e.g. `bytes = + // hashfunc([...namespace, ... value])` + + + let bytes = new Uint8Array(16 + value.length); + bytes.set(namespace); + bytes.set(value, namespace.length); + bytes = hashfunc(bytes); + bytes[6] = bytes[6] & 0x0f | version; + bytes[8] = bytes[8] & 0x3f | 0x80; + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + + return buf; + } + + return (0, _stringify.default)(bytes); + } // Function#name is not settable on some platforms (#270) + + + try { + generateUUID.name = name; // eslint-disable-next-line no-empty + } catch (err) {} // For CommonJS default export support + + + generateUUID.DNS = DNS; + generateUUID.URL = URL; + return generateUUID; +} + +/***/ }), + +/***/ 85122: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(50807)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function v4(options, buf, offset) { + options = options || {}; + + const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + + + rnds[6] = rnds[6] & 0x0f | 0x40; + rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + + return buf; + } + + return (0, _stringify.default)(rnds); +} + +var _default = v4; +exports["default"] = _default; + +/***/ }), + +/***/ 79120: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(65998)); + +var _sha = _interopRequireDefault(__nccwpck_require__(85274)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const v5 = (0, _v.default)('v5', 0x50, _sha.default); +var _default = v5; +exports["default"] = _default; + +/***/ }), + +/***/ 66900: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(__nccwpck_require__(40814)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function validate(uuid) { + return typeof uuid === 'string' && _regex.default.test(uuid); +} + +var _default = validate; +exports["default"] = _default; + +/***/ }), + +/***/ 81595: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(66900)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function version(uuid) { + if (!(0, _validate.default)(uuid)) { + throw TypeError('Invalid UUID'); + } + + return parseInt(uuid.substr(14, 1), 16); +} + +var _default = version; +exports["default"] = _default; + +/***/ }), + +/***/ 15633: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var iconvLite = __nccwpck_require__(85848); +var iconvLite = __nccwpck_require__(42550); // Expose to the world module.exports.O = convert; @@ -92,12 +5216,12 @@ function checkEncoding(name) { /***/ }), -/***/ 77668: +/***/ 43511: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // Multibyte codec. In this scheme, a character is represented by 1 or more bytes. // Our codec supports UTF-16 surrogates, extensions for GB18030 and unicode sequences. @@ -697,7 +5821,7 @@ function findIdx(table, val) { /***/ }), -/***/ 39478: +/***/ 39093: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -743,7 +5867,7 @@ module.exports = { 'shiftjis': { type: '_dbcs', - table: function() { return __nccwpck_require__(48064) }, + table: function() { return __nccwpck_require__(79561) }, encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E}, encodeSkipVals: [{from: 0xED40, to: 0xF940}], }, @@ -760,7 +5884,7 @@ module.exports = { 'eucjp': { type: '_dbcs', - table: function() { return __nccwpck_require__(64688) }, + table: function() { return __nccwpck_require__(78419) }, encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E}, }, @@ -787,13 +5911,13 @@ module.exports = { '936': 'cp936', 'cp936': { type: '_dbcs', - table: function() { return __nccwpck_require__(85497) }, + table: function() { return __nccwpck_require__(64934) }, }, // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other. 'gbk': { type: '_dbcs', - table: function() { return (__nccwpck_require__(85497).concat)(__nccwpck_require__(49670)) }, + table: function() { return (__nccwpck_require__(64934).concat)(__nccwpck_require__(2191)) }, }, 'xgbk': 'gbk', 'isoir58': 'gbk', @@ -805,8 +5929,8 @@ module.exports = { // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0 'gb18030': { type: '_dbcs', - table: function() { return (__nccwpck_require__(85497).concat)(__nccwpck_require__(49670)) }, - gb18030: function() { return __nccwpck_require__(19331) }, + table: function() { return (__nccwpck_require__(64934).concat)(__nccwpck_require__(2191)) }, + gb18030: function() { return __nccwpck_require__(39498) }, encodeSkipVals: [0x80], encodeAdd: {'€': 0xA2E3}, }, @@ -821,7 +5945,7 @@ module.exports = { '949': 'cp949', 'cp949': { type: '_dbcs', - table: function() { return __nccwpck_require__(99519) }, + table: function() { return __nccwpck_require__(22885) }, }, 'cseuckr': 'cp949', @@ -862,14 +5986,14 @@ module.exports = { '950': 'cp950', 'cp950': { type: '_dbcs', - table: function() { return __nccwpck_require__(31745) }, + table: function() { return __nccwpck_require__(15154) }, }, // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus. 'big5': 'big5hkscs', 'big5hkscs': { type: '_dbcs', - table: function() { return (__nccwpck_require__(31745).concat)(__nccwpck_require__(93991)) }, + table: function() { return (__nccwpck_require__(15154).concat)(__nccwpck_require__(25936)) }, encodeSkipVals: [ // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU. @@ -893,7 +6017,7 @@ module.exports = { /***/ }), -/***/ 16386: +/***/ 52907: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -902,15 +6026,15 @@ module.exports = { // Update this array if you add/rename/remove files in this directory. // We support Browserify by skipping automatic module discovery and requiring modules directly. var modules = [ - __nccwpck_require__(27489), - __nccwpck_require__(55341), - __nccwpck_require__(32602), - __nccwpck_require__(49451), - __nccwpck_require__(96441), - __nccwpck_require__(99118), - __nccwpck_require__(70820), - __nccwpck_require__(77668), - __nccwpck_require__(39478), + __nccwpck_require__(78891), + __nccwpck_require__(76034), + __nccwpck_require__(32360), + __nccwpck_require__(30087), + __nccwpck_require__(48264), + __nccwpck_require__(49680), + __nccwpck_require__(92545), + __nccwpck_require__(43511), + __nccwpck_require__(39093), ]; // Put all encoding/alias/codec definitions to single object and export it. @@ -924,12 +6048,12 @@ for (var i = 0; i < modules.length; i++) { /***/ }), -/***/ 27489: +/***/ 78891: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // Export Node.js internal encodings. @@ -1130,12 +6254,12 @@ InternalDecoderCesu8.prototype.end = function() { /***/ }), -/***/ 96441: +/***/ 48264: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that // correspond to encoded bytes (if 128 - then lower half is ASCII). @@ -1210,7 +6334,7 @@ SBCSDecoder.prototype.end = function() { /***/ }), -/***/ 70820: +/***/ 92545: /***/ ((module) => { "use strict"; @@ -1668,7 +6792,7 @@ module.exports = { /***/ }), -/***/ 99118: +/***/ 49680: /***/ ((module) => { "use strict"; @@ -1855,12 +6979,12 @@ module.exports = { /***/ }), -/***/ 32602: +/***/ 32360: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js @@ -2060,13 +7184,13 @@ function detectEncoding(bufs, defaultEncoding) { /***/ }), -/***/ 55341: +/***/ 76034: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // == UTF32-LE/BE codec. ========================================================== @@ -2387,12 +7511,12 @@ function detectEncoding(bufs, defaultEncoding) { /***/ }), -/***/ 49451: +/***/ 30087: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // UTF-7 codec, according to https://tools.ietf.org/html/rfc2152 // See also below a UTF-7-IMAP codec, according to http://tools.ietf.org/html/rfc3501#section-5.1.3 @@ -2685,7 +7809,7 @@ Utf7IMAPDecoder.prototype.end = function() { /***/ }), -/***/ 88006: +/***/ 16757: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -2745,15 +7869,15 @@ StripBOMWrapper.prototype.end = function() { /***/ }), -/***/ 85848: +/***/ 42550: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); -var bomHandling = __nccwpck_require__(88006), +var bomHandling = __nccwpck_require__(16757), iconv = module.exports; // All codecs and aliases are kept here, keyed by encoding name/alias. @@ -2811,7 +7935,7 @@ iconv.fromEncoding = iconv.decode; iconv._codecDataCache = {}; iconv.getCodec = function getCodec(encoding) { if (!iconv.encodings) - iconv.encodings = __nccwpck_require__(16386); // Lazy load all encoding definitions. + iconv.encodings = __nccwpck_require__(52907); // Lazy load all encoding definitions. // Canonicalize encoding name: strip all non-alphanumeric chars and appended year. var enc = iconv._canonicalizeEncoding(encoding); @@ -2892,7 +8016,7 @@ iconv.enableStreamingAPI = function enableStreamingAPI(stream_module) { return; // Dependency-inject stream module to create IconvLite stream classes. - var streams = __nccwpck_require__(58783)(stream_module); + var streams = __nccwpck_require__(79823)(stream_module); // Not public API yet, but expose the stream classes. iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream; @@ -2931,13 +8055,13 @@ if (false) {} /***/ }), -/***/ 58783: +/***/ 79823: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(97084).Buffer); +var Buffer = (__nccwpck_require__(1822).Buffer); // NOTE: Due to 'stream' module being pretty large (~100Kb, significant in browser environments), // we opt to dependency-inject it instead of creating a hard dependency. @@ -3048,7 +8172,7 @@ module.exports = function(stream_module) { /***/ }), -/***/ 97084: +/***/ 1822: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -3133,7 +8257,7 @@ module.exports = safer /***/ }), -/***/ 99860: +/***/ 15545: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -3154,11 +8278,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.create = void 0; -const client_1 = __nccwpck_require__(23955); +const client_1 = __nccwpck_require__(68029); /** * Exported functionality that we want to expose for any users of @actions/artifact */ -__exportStar(__nccwpck_require__(2538), exports); +__exportStar(__nccwpck_require__(28546), exports); function create() { return client_1.Client.create(); } @@ -3167,20 +8291,20 @@ exports.create = create; /***/ }), -/***/ 68066: +/***/ 7397: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Timestamp = void 0; -const runtime_1 = __nccwpck_require__(90076); -const runtime_2 = __nccwpck_require__(90076); -const runtime_3 = __nccwpck_require__(90076); -const runtime_4 = __nccwpck_require__(90076); -const runtime_5 = __nccwpck_require__(90076); -const runtime_6 = __nccwpck_require__(90076); -const runtime_7 = __nccwpck_require__(90076); +const runtime_1 = __nccwpck_require__(65204); +const runtime_2 = __nccwpck_require__(65204); +const runtime_3 = __nccwpck_require__(65204); +const runtime_4 = __nccwpck_require__(65204); +const runtime_5 = __nccwpck_require__(65204); +const runtime_6 = __nccwpck_require__(65204); +const runtime_7 = __nccwpck_require__(65204); // @generated message type with reflection information, may provide speed optimized methods class Timestamp$Type extends runtime_7.MessageType { constructor() { @@ -3310,7 +8434,7 @@ exports.Timestamp = new Timestamp$Type(); /***/ }), -/***/ 97610: +/***/ 29363: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -3357,13 +8481,13 @@ exports.BytesValue = exports.StringValue = exports.BoolValue = exports.UInt32Val // where we need to distinguish between the absence of a primitive // typed field and its default value. // -const runtime_1 = __nccwpck_require__(90076); -const runtime_2 = __nccwpck_require__(90076); -const runtime_3 = __nccwpck_require__(90076); -const runtime_4 = __nccwpck_require__(90076); -const runtime_5 = __nccwpck_require__(90076); -const runtime_6 = __nccwpck_require__(90076); -const runtime_7 = __nccwpck_require__(90076); +const runtime_1 = __nccwpck_require__(65204); +const runtime_2 = __nccwpck_require__(65204); +const runtime_3 = __nccwpck_require__(65204); +const runtime_4 = __nccwpck_require__(65204); +const runtime_5 = __nccwpck_require__(65204); +const runtime_6 = __nccwpck_require__(65204); +const runtime_7 = __nccwpck_require__(65204); // @generated message type with reflection information, may provide speed optimized methods class DoubleValue$Type extends runtime_7.MessageType { constructor() { @@ -3926,7 +9050,7 @@ exports.BytesValue = new BytesValue$Type(); /***/ }), -/***/ 90265: +/***/ 56927: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -3946,15 +9070,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(68066), exports); -__exportStar(__nccwpck_require__(97610), exports); -__exportStar(__nccwpck_require__(76025), exports); -__exportStar(__nccwpck_require__(84701), exports); +__exportStar(__nccwpck_require__(7397), exports); +__exportStar(__nccwpck_require__(29363), exports); +__exportStar(__nccwpck_require__(50919), exports); +__exportStar(__nccwpck_require__(20508), exports); //# sourceMappingURL=index.js.map /***/ }), -/***/ 76025: +/***/ 50919: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -3964,14 +9088,14 @@ exports.ArtifactService = exports.FinalizeArtifactResponse = exports.FinalizeArt // @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies // @generated from protobuf file "results/api/v1/artifact.proto" (package "github.actions.results.api.v1", syntax proto3) // tslint:disable -const runtime_rpc_1 = __nccwpck_require__(81745); -const runtime_1 = __nccwpck_require__(90076); -const runtime_2 = __nccwpck_require__(90076); -const runtime_3 = __nccwpck_require__(90076); -const runtime_4 = __nccwpck_require__(90076); -const runtime_5 = __nccwpck_require__(90076); -const wrappers_1 = __nccwpck_require__(97610); -const timestamp_1 = __nccwpck_require__(68066); +const runtime_rpc_1 = __nccwpck_require__(34755); +const runtime_1 = __nccwpck_require__(65204); +const runtime_2 = __nccwpck_require__(65204); +const runtime_3 = __nccwpck_require__(65204); +const runtime_4 = __nccwpck_require__(65204); +const runtime_5 = __nccwpck_require__(65204); +const wrappers_1 = __nccwpck_require__(29363); +const timestamp_1 = __nccwpck_require__(7397); // @generated message type with reflection information, may provide speed optimized methods class CreateArtifactRequest$Type extends runtime_5.MessageType { constructor() { @@ -4241,7 +9365,7 @@ exports.ArtifactService = new runtime_rpc_1.ServiceType("github.actions.results. /***/ }), -/***/ 84701: +/***/ 20508: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4257,8 +9381,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createArtifactServiceServer = exports.ArtifactServiceMethodList = exports.ArtifactServiceMethod = exports.ArtifactServiceClientProtobuf = exports.ArtifactServiceClientJSON = void 0; -const twirp_ts_1 = __nccwpck_require__(68053); -const artifact_1 = __nccwpck_require__(76025); +const twirp_ts_1 = __nccwpck_require__(76676); +const artifact_1 = __nccwpck_require__(50919); class ArtifactServiceClientJSON { constructor(rpc) { this.rpc = rpc; @@ -4478,7 +9602,7 @@ function handleArtifactServiceFinalizeArtifactProtobuf(ctx, service, data, inter /***/ }), -/***/ 23955: +/***/ 68029: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4494,12 +9618,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Client = void 0; -const core_1 = __nccwpck_require__(66526); -const config_1 = __nccwpck_require__(95042); -const upload_artifact_1 = __nccwpck_require__(86278); -const download_artifact_1 = __nccwpck_require__(17306); -const get_artifact_1 = __nccwpck_require__(56218); -const list_artifacts_1 = __nccwpck_require__(64033); +const core_1 = __nccwpck_require__(17796); +const config_1 = __nccwpck_require__(48523); +const upload_artifact_1 = __nccwpck_require__(94411); +const download_artifact_1 = __nccwpck_require__(5972); +const get_artifact_1 = __nccwpck_require__(18571); +const list_artifacts_1 = __nccwpck_require__(97443); class Client { /** * Constructs a Client @@ -4617,7 +9741,7 @@ exports.Client = Client; /***/ }), -/***/ 17306: +/***/ 5972: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4660,12 +9784,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.downloadArtifact = void 0; const promises_1 = __importDefault(__nccwpck_require__(73292)); -const github = __importStar(__nccwpck_require__(51132)); -const core = __importStar(__nccwpck_require__(66526)); -const httpClient = __importStar(__nccwpck_require__(52932)); -const unzipper_1 = __importDefault(__nccwpck_require__(80686)); -const user_agent_1 = __nccwpck_require__(79681); -const config_1 = __nccwpck_require__(95042); +const github = __importStar(__nccwpck_require__(23855)); +const core = __importStar(__nccwpck_require__(17796)); +const httpClient = __importStar(__nccwpck_require__(70045)); +const unzipper_1 = __importDefault(__nccwpck_require__(36827)); +const user_agent_1 = __nccwpck_require__(7070); +const config_1 = __nccwpck_require__(48523); const scrubQueryParameters = (url) => { const parsed = new URL(url); parsed.search = ''; @@ -4742,7 +9866,7 @@ exports.downloadArtifact = downloadArtifact; /***/ }), -/***/ 56218: +/***/ 18571: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4781,13 +9905,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getArtifact = void 0; -const github_1 = __nccwpck_require__(51132); -const user_agent_1 = __nccwpck_require__(79681); -const utils_1 = __nccwpck_require__(43129); -const retry_options_1 = __nccwpck_require__(80722); -const plugin_request_log_1 = __nccwpck_require__(73665); -const plugin_retry_1 = __nccwpck_require__(69980); -const core = __importStar(__nccwpck_require__(66526)); +const github_1 = __nccwpck_require__(23855); +const user_agent_1 = __nccwpck_require__(7070); +const utils_1 = __nccwpck_require__(31383); +const retry_options_1 = __nccwpck_require__(59414); +const plugin_request_log_1 = __nccwpck_require__(21876); +const plugin_retry_1 = __nccwpck_require__(17083); +const core = __importStar(__nccwpck_require__(17796)); function getArtifact(artifactName, workflowRunId, repositoryOwner, repositoryName, token) { return __awaiter(this, void 0, void 0, function* () { const [retryOpts, requestOpts] = (0, retry_options_1.getRetryOptions)(utils_1.defaults); @@ -4836,7 +9960,7 @@ exports.getArtifact = getArtifact; /***/ }), -/***/ 64033: +/***/ 97443: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4852,13 +9976,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.listArtifacts = void 0; -const core_1 = __nccwpck_require__(66526); -const github_1 = __nccwpck_require__(51132); -const user_agent_1 = __nccwpck_require__(79681); -const retry_options_1 = __nccwpck_require__(80722); -const utils_1 = __nccwpck_require__(43129); -const plugin_request_log_1 = __nccwpck_require__(73665); -const plugin_retry_1 = __nccwpck_require__(69980); +const core_1 = __nccwpck_require__(17796); +const github_1 = __nccwpck_require__(23855); +const user_agent_1 = __nccwpck_require__(7070); +const retry_options_1 = __nccwpck_require__(59414); +const utils_1 = __nccwpck_require__(31383); +const plugin_request_log_1 = __nccwpck_require__(21876); +const plugin_retry_1 = __nccwpck_require__(17083); // Limiting to 1000 for perf reasons const maximumArtifactCount = 1000; const paginationCount = 100; @@ -4930,7 +10054,7 @@ exports.listArtifacts = listArtifacts; /***/ }), -/***/ 80722: +/***/ 59414: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -4960,7 +10084,7 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getRetryOptions = void 0; -const core = __importStar(__nccwpck_require__(66526)); +const core = __importStar(__nccwpck_require__(17796)); // Defaults for fetching artifacts const defaultMaxRetryNumber = 5; const defaultExemptStatusCodes = [400, 401, 403, 404, 422]; // https://github.com/octokit/plugin-retry.js/blob/9a2443746c350b3beedec35cf26e197ea318a261/src/index.ts#L14 @@ -4987,7 +10111,7 @@ exports.getRetryOptions = getRetryOptions; /***/ }), -/***/ 63550: +/***/ 51991: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5003,11 +10127,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createArtifactTwirpClient = void 0; -const http_client_1 = __nccwpck_require__(52932); -const auth_1 = __nccwpck_require__(40903); -const core_1 = __nccwpck_require__(66526); -const generated_1 = __nccwpck_require__(90265); -const config_1 = __nccwpck_require__(95042); +const http_client_1 = __nccwpck_require__(70045); +const auth_1 = __nccwpck_require__(47251); +const core_1 = __nccwpck_require__(17796); +const generated_1 = __nccwpck_require__(56927); +const config_1 = __nccwpck_require__(48523); class ArtifactHttpClient { constructor(userAgent, maxAttempts, baseRetryIntervalMilliseconds, retryMultiplier) { this.maxAttempts = 5; @@ -5125,7 +10249,7 @@ exports.createArtifactTwirpClient = createArtifactTwirpClient; /***/ }), -/***/ 95042: +/***/ 48523: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -5171,7 +10295,7 @@ exports.getGitHubWorkspaceDir = getGitHubWorkspaceDir; /***/ }), -/***/ 2538: +/***/ 28546: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -5181,7 +10305,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 79681: +/***/ 7070: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -5189,7 +10313,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getUserAgentString = void 0; // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports -const packageJson = __nccwpck_require__(9303); +const packageJson = __nccwpck_require__(71896); /** * Ensure that this User Agent String is used in all HTTP calls so that we can monitor telemetry between different versions of this package */ @@ -5201,7 +10325,7 @@ exports.getUserAgentString = getUserAgentString; /***/ }), -/***/ 80565: +/***/ 11713: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5211,8 +10335,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getBackendIdsFromToken = void 0; -const config_1 = __nccwpck_require__(95042); -const jwt_decode_1 = __importDefault(__nccwpck_require__(25582)); +const config_1 = __nccwpck_require__(48523); +const jwt_decode_1 = __importDefault(__nccwpck_require__(49929)); const InvalidJwtError = new Error('Failed to get backend IDs: The provided JWT token is invalid'); // uses the JWT token claims to get the // workflow run and workflow job run backend ids @@ -5262,7 +10386,7 @@ exports.getBackendIdsFromToken = getBackendIdsFromToken; /***/ }), -/***/ 63311: +/***/ 57276: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5301,9 +10425,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.uploadZipToBlobStorage = void 0; -const storage_blob_1 = __nccwpck_require__(18061); -const config_1 = __nccwpck_require__(95042); -const core = __importStar(__nccwpck_require__(66526)); +const storage_blob_1 = __nccwpck_require__(30740); +const config_1 = __nccwpck_require__(48523); +const core = __importStar(__nccwpck_require__(17796)); const crypto = __importStar(__nccwpck_require__(6113)); const stream = __importStar(__nccwpck_require__(12781)); function uploadZipToBlobStorage(authenticatedUploadURL, zipUploadStream) { @@ -5359,14 +10483,14 @@ exports.uploadZipToBlobStorage = uploadZipToBlobStorage; /***/ }), -/***/ 4913: +/***/ 20778: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.validateFilePath = exports.validateArtifactName = void 0; -const core_1 = __nccwpck_require__(66526); +const core_1 = __nccwpck_require__(17796); /** * Invalid characters that cannot be in the artifact name or an uploaded file. Will be rejected * from the server if attempted to be sent over. These characters are not allowed due to limitations with certain @@ -5433,7 +10557,7 @@ exports.validateFilePath = validateFilePath; /***/ }), -/***/ 79245: +/***/ 97775: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5463,8 +10587,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getExpiration = void 0; -const generated_1 = __nccwpck_require__(90265); -const core = __importStar(__nccwpck_require__(66526)); +const generated_1 = __nccwpck_require__(56927); +const core = __importStar(__nccwpck_require__(17796)); function getExpiration(retentionDays) { if (!retentionDays) { return undefined; @@ -5494,7 +10618,7 @@ function getRetentionDays() { /***/ }), -/***/ 86278: +/***/ 94411: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5533,15 +10657,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.uploadArtifact = void 0; -const core = __importStar(__nccwpck_require__(66526)); -const retention_1 = __nccwpck_require__(79245); -const path_and_artifact_name_validation_1 = __nccwpck_require__(4913); -const artifact_twirp_client_1 = __nccwpck_require__(63550); -const upload_zip_specification_1 = __nccwpck_require__(16206); -const util_1 = __nccwpck_require__(80565); -const blob_upload_1 = __nccwpck_require__(63311); -const zip_1 = __nccwpck_require__(6180); -const generated_1 = __nccwpck_require__(90265); +const core = __importStar(__nccwpck_require__(17796)); +const retention_1 = __nccwpck_require__(97775); +const path_and_artifact_name_validation_1 = __nccwpck_require__(20778); +const artifact_twirp_client_1 = __nccwpck_require__(51991); +const upload_zip_specification_1 = __nccwpck_require__(84299); +const util_1 = __nccwpck_require__(11713); +const blob_upload_1 = __nccwpck_require__(57276); +const zip_1 = __nccwpck_require__(42805); +const generated_1 = __nccwpck_require__(56927); function uploadArtifact(name, files, rootDirectory, options) { return __awaiter(this, void 0, void 0, function* () { (0, path_and_artifact_name_validation_1.validateArtifactName)(name); @@ -5626,7 +10750,7 @@ exports.uploadArtifact = uploadArtifact; /***/ }), -/***/ 16206: +/***/ 84299: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5657,9 +10781,9 @@ var __importStar = (this && this.__importStar) || function (mod) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getUploadZipSpecification = exports.validateRootDirectory = void 0; const fs = __importStar(__nccwpck_require__(57147)); -const core_1 = __nccwpck_require__(66526); +const core_1 = __nccwpck_require__(17796); const path_1 = __nccwpck_require__(71017); -const path_and_artifact_name_validation_1 = __nccwpck_require__(4913); +const path_and_artifact_name_validation_1 = __nccwpck_require__(20778); /** * Checks if a root directory exists and is valid * @param rootDirectory an absolute root directory path common to all input files that that will be trimmed from the final zip structure @@ -5746,7 +10870,7 @@ exports.getUploadZipSpecification = getUploadZipSpecification; /***/ }), -/***/ 6180: +/***/ 42805: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5786,10 +10910,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createZipUploadStream = exports.ZipUploadStream = void 0; const stream = __importStar(__nccwpck_require__(12781)); -const archiver = __importStar(__nccwpck_require__(71160)); -const core = __importStar(__nccwpck_require__(66526)); +const archiver = __importStar(__nccwpck_require__(17813)); +const core = __importStar(__nccwpck_require__(17796)); const fs_1 = __nccwpck_require__(57147); -const config_1 = __nccwpck_require__(95042); +const config_1 = __nccwpck_require__(48523); // Custom stream transformer so we can set the highWaterMark property // See https://github.com/nodejs/node/issues/8855 class ZipUploadStream extends stream.Transform { @@ -5867,7 +10991,7 @@ const zipEndCallback = () => { /***/ }), -/***/ 29835: +/***/ 97533: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -5894,7 +11018,7 @@ var __importStar = (this && this.__importStar) || function (mod) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.issue = exports.issueCommand = void 0; const os = __importStar(__nccwpck_require__(22037)); -const utils_1 = __nccwpck_require__(85932); +const utils_1 = __nccwpck_require__(63204); /** * Commands * @@ -5966,7 +11090,7 @@ function escapeProperty(s) { /***/ }), -/***/ 66526: +/***/ 17796: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6001,12 +11125,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; -const command_1 = __nccwpck_require__(29835); -const file_command_1 = __nccwpck_require__(71117); -const utils_1 = __nccwpck_require__(85932); +const command_1 = __nccwpck_require__(97533); +const file_command_1 = __nccwpck_require__(69232); +const utils_1 = __nccwpck_require__(63204); const os = __importStar(__nccwpck_require__(22037)); const path = __importStar(__nccwpck_require__(71017)); -const oidc_utils_1 = __nccwpck_require__(64663); +const oidc_utils_1 = __nccwpck_require__(79113); /** * The code to exit an action */ @@ -6291,17 +11415,17 @@ exports.getIDToken = getIDToken; /** * Summary exports */ -var summary_1 = __nccwpck_require__(71861); +var summary_1 = __nccwpck_require__(216); Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); /** * @deprecated use core.summary */ -var summary_2 = __nccwpck_require__(71861); +var summary_2 = __nccwpck_require__(216); Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); /** * Path exports */ -var path_utils_1 = __nccwpck_require__(48077); +var path_utils_1 = __nccwpck_require__(33172); Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); @@ -6309,7 +11433,7 @@ Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: funct /***/ }), -/***/ 71117: +/***/ 69232: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6340,8 +11464,8 @@ exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; /* eslint-disable @typescript-eslint/no-explicit-any */ const fs = __importStar(__nccwpck_require__(57147)); const os = __importStar(__nccwpck_require__(22037)); -const uuid_1 = __nccwpck_require__(4413); -const utils_1 = __nccwpck_require__(85932); +const uuid_1 = __nccwpck_require__(27405); +const utils_1 = __nccwpck_require__(63204); function issueFileCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; if (!filePath) { @@ -6374,7 +11498,7 @@ exports.prepareKeyValueMessage = prepareKeyValueMessage; /***/ }), -/***/ 64663: +/***/ 79113: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6390,9 +11514,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.OidcClient = void 0; -const http_client_1 = __nccwpck_require__(52932); -const auth_1 = __nccwpck_require__(40903); -const core_1 = __nccwpck_require__(66526); +const http_client_1 = __nccwpck_require__(70045); +const auth_1 = __nccwpck_require__(47251); +const core_1 = __nccwpck_require__(17796); class OidcClient { static createHttpClient(allowRetry = true, maxRetry = 10) { const requestOptions = { @@ -6458,7 +11582,7 @@ exports.OidcClient = OidcClient; /***/ }), -/***/ 48077: +/***/ 33172: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6523,7 +11647,7 @@ exports.toPlatformPath = toPlatformPath; /***/ }), -/***/ 71861: +/***/ 216: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6813,7 +11937,7 @@ exports.summary = _summary; /***/ }), -/***/ 85932: +/***/ 63204: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -6860,7 +11984,7 @@ exports.toCommandProperties = toCommandProperties; /***/ }), -/***/ 78489: +/***/ 99534: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -6921,7 +12045,7 @@ exports.Context = Context; /***/ }), -/***/ 51132: +/***/ 23855: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6947,8 +12071,8 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(78489)); -const utils_1 = __nccwpck_require__(43129); +const Context = __importStar(__nccwpck_require__(99534)); +const utils_1 = __nccwpck_require__(31383); exports.context = new Context.Context(); /** * Returns a hydrated octokit ready to use for GitHub Actions @@ -6965,7 +12089,7 @@ exports.getOctokit = getOctokit; /***/ }), -/***/ 31179: +/***/ 32530: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -6991,7 +12115,7 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0; -const httpClient = __importStar(__nccwpck_require__(52932)); +const httpClient = __importStar(__nccwpck_require__(70045)); function getAuthString(token, options) { if (!token && !options.auth) { throw new Error('Parameter token or opts.auth is required'); @@ -7015,7 +12139,7 @@ exports.getApiBaseUrl = getApiBaseUrl; /***/ }), -/***/ 43129: +/***/ 31383: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -7041,12 +12165,12 @@ var __importStar = (this && this.__importStar) || function (mod) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getOctokitOptions = exports.GitHub = exports.defaults = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(78489)); -const Utils = __importStar(__nccwpck_require__(31179)); +const Context = __importStar(__nccwpck_require__(99534)); +const Utils = __importStar(__nccwpck_require__(32530)); // octokit + plugins -const core_1 = __nccwpck_require__(34266); -const plugin_rest_endpoint_methods_1 = __nccwpck_require__(68590); -const plugin_paginate_rest_1 = __nccwpck_require__(60345); +const core_1 = __nccwpck_require__(28388); +const plugin_rest_endpoint_methods_1 = __nccwpck_require__(55601); +const plugin_paginate_rest_1 = __nccwpck_require__(64279); exports.context = new Context.Context(); const baseUrl = Utils.getApiBaseUrl(); exports.defaults = { @@ -7076,7 +12200,7 @@ exports.getOctokitOptions = getOctokitOptions; /***/ }), -/***/ 40903: +/***/ 47251: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -7164,7 +12288,7 @@ exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHand /***/ }), -/***/ 52932: +/***/ 70045: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -7202,8 +12326,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; const http = __importStar(__nccwpck_require__(13685)); const https = __importStar(__nccwpck_require__(95687)); -const pm = __importStar(__nccwpck_require__(34465)); -const tunnel = __importStar(__nccwpck_require__(20791)); +const pm = __importStar(__nccwpck_require__(93539)); +const tunnel = __importStar(__nccwpck_require__(88593)); var HttpCodes; (function (HttpCodes) { HttpCodes[HttpCodes["OK"] = 200] = "OK"; @@ -7776,7 +12900,7 @@ const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCa /***/ }), -/***/ 34465: +/***/ 93539: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -7859,7 +12983,7 @@ function isLoopbackAddress(host) { /***/ }), -/***/ 46889: +/***/ 43264: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -8106,7 +13230,7 @@ exports.AbortSignal = AbortSignal; /***/ }), -/***/ 81417: +/***/ 43695: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -8114,7 +13238,7 @@ exports.AbortSignal = AbortSignal; Object.defineProperty(exports, "__esModule", ({ value: true })); -var coreUtil = __nccwpck_require__(47574); +var coreUtil = __nccwpck_require__(22603); // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. @@ -8292,7 +13416,7 @@ exports.isTokenCredential = isTokenCredential; /***/ }), -/***/ 85643: +/***/ 84251: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -8300,22 +13424,22 @@ exports.isTokenCredential = isTokenCredential; Object.defineProperty(exports, "__esModule", ({ value: true })); -var uuid = __nccwpck_require__(4413); +var uuid = __nccwpck_require__(27405); var util = __nccwpck_require__(73837); -var tslib = __nccwpck_require__(92716); -var xml2js = __nccwpck_require__(50827); -var coreUtil = __nccwpck_require__(47574); -var logger$1 = __nccwpck_require__(68476); -var coreAuth = __nccwpck_require__(81417); +var tslib = __nccwpck_require__(89027); +var xml2js = __nccwpck_require__(99440); +var coreUtil = __nccwpck_require__(22603); +var logger$1 = __nccwpck_require__(19505); +var coreAuth = __nccwpck_require__(43695); var os = __nccwpck_require__(22037); var http = __nccwpck_require__(13685); var https = __nccwpck_require__(95687); -var abortController = __nccwpck_require__(46889); -var tunnel = __nccwpck_require__(20791); +var abortController = __nccwpck_require__(43264); +var tunnel = __nccwpck_require__(88593); var stream = __nccwpck_require__(12781); -var FormData = __nccwpck_require__(79700); -var node_fetch = __nccwpck_require__(96295); -var coreTracing = __nccwpck_require__(22001); +var FormData = __nccwpck_require__(44374); +var node_fetch = __nccwpck_require__(35325); +var coreTracing = __nccwpck_require__(94510); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } @@ -13765,7 +18889,7 @@ exports.userAgentPolicy = userAgentPolicy; /***/ }), -/***/ 59158: +/***/ 56106: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -13773,9 +18897,9 @@ exports.userAgentPolicy = userAgentPolicy; Object.defineProperty(exports, "__esModule", ({ value: true })); -var logger$1 = __nccwpck_require__(68476); -var abortController = __nccwpck_require__(46889); -var coreUtil = __nccwpck_require__(47574); +var logger$1 = __nccwpck_require__(19505); +var abortController = __nccwpck_require__(43264); +var coreUtil = __nccwpck_require__(22603); // Copyright (c) Microsoft Corporation. /** @@ -14941,7 +20065,7 @@ exports.createHttpPoller = createHttpPoller; /***/ }), -/***/ 7595: +/***/ 10793: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -14949,7 +20073,7 @@ exports.createHttpPoller = createHttpPoller; Object.defineProperty(exports, "__esModule", ({ value: true })); -var tslib = __nccwpck_require__(92716); +var tslib = __nccwpck_require__(89027); // Copyright (c) Microsoft Corporation. /** @@ -15053,7 +20177,7 @@ exports.getPagedAsyncIterator = getPagedAsyncIterator; /***/ }), -/***/ 22001: +/***/ 94510: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -15061,7 +20185,7 @@ exports.getPagedAsyncIterator = getPagedAsyncIterator; Object.defineProperty(exports, "__esModule", ({ value: true })); -var api = __nccwpck_require__(27742); +var api = __nccwpck_require__(9365); // Copyright (c) Microsoft Corporation. (function (SpanKind) { @@ -15280,7 +20404,7 @@ exports.setSpanContext = setSpanContext; /***/ }), -/***/ 47574: +/***/ 22603: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -15288,7 +20412,7 @@ exports.setSpanContext = setSpanContext; Object.defineProperty(exports, "__esModule", ({ value: true })); -var abortController = __nccwpck_require__(46889); +var abortController = __nccwpck_require__(43264); var crypto = __nccwpck_require__(6113); // Copyright (c) Microsoft Corporation. @@ -15673,7 +20797,7 @@ exports.uint8ArrayToString = uint8ArrayToString; /***/ }), -/***/ 68476: +/***/ 19505: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -15889,7 +21013,7 @@ exports.setLogLevel = setLogLevel; /***/ }), -/***/ 18061: +/***/ 30740: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -15897,16 +21021,16 @@ exports.setLogLevel = setLogLevel; Object.defineProperty(exports, "__esModule", ({ value: true })); -var coreHttp = __nccwpck_require__(85643); -var tslib = __nccwpck_require__(92716); -var coreTracing = __nccwpck_require__(22001); -var logger$1 = __nccwpck_require__(68476); -var abortController = __nccwpck_require__(46889); +var coreHttp = __nccwpck_require__(84251); +var tslib = __nccwpck_require__(89027); +var coreTracing = __nccwpck_require__(94510); +var logger$1 = __nccwpck_require__(19505); +var abortController = __nccwpck_require__(43264); var os = __nccwpck_require__(22037); var crypto = __nccwpck_require__(6113); var stream = __nccwpck_require__(12781); -__nccwpck_require__(7595); -var coreLro = __nccwpck_require__(59158); +__nccwpck_require__(10793); +var coreLro = __nccwpck_require__(56106); var events = __nccwpck_require__(82361); var fs = __nccwpck_require__(57147); var util = __nccwpck_require__(73837); @@ -41014,7 +46138,7 @@ exports.newPipeline = newPipeline; /***/ }), -/***/ 15234: +/***/ 88121: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -41077,7 +46201,7 @@ exports.createTokenAuth = createTokenAuth; /***/ }), -/***/ 34266: +/***/ 28388: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -41085,11 +46209,11 @@ exports.createTokenAuth = createTokenAuth; Object.defineProperty(exports, "__esModule", ({ value: true })); -var universalUserAgent = __nccwpck_require__(68636); -var beforeAfterHook = __nccwpck_require__(18079); -var request = __nccwpck_require__(40857); -var graphql = __nccwpck_require__(51977); -var authToken = __nccwpck_require__(15234); +var universalUserAgent = __nccwpck_require__(40996); +var beforeAfterHook = __nccwpck_require__(10974); +var request = __nccwpck_require__(10073); +var graphql = __nccwpck_require__(57800); +var authToken = __nccwpck_require__(88121); function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; @@ -41261,7 +46385,7 @@ exports.Octokit = Octokit; /***/ }), -/***/ 28124: +/***/ 25262: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -41269,8 +46393,8 @@ exports.Octokit = Octokit; Object.defineProperty(exports, "__esModule", ({ value: true })); -var isPlainObject = __nccwpck_require__(54132); -var universalUserAgent = __nccwpck_require__(68636); +var isPlainObject = __nccwpck_require__(30655); +var universalUserAgent = __nccwpck_require__(40996); function lowercaseKeys(object) { if (!object) { @@ -41659,7 +46783,7 @@ exports.endpoint = endpoint; /***/ }), -/***/ 51977: +/***/ 57800: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -41667,8 +46791,8 @@ exports.endpoint = endpoint; Object.defineProperty(exports, "__esModule", ({ value: true })); -var request = __nccwpck_require__(40857); -var universalUserAgent = __nccwpck_require__(68636); +var request = __nccwpck_require__(10073); +var universalUserAgent = __nccwpck_require__(40996); const VERSION = "4.8.0"; @@ -41785,7 +46909,7 @@ exports.withCustomRequest = withCustomRequest; /***/ }), -/***/ 60345: +/***/ 64279: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -41998,7 +47122,7 @@ exports.paginatingEndpoints = paginatingEndpoints; /***/ }), -/***/ 73665: +/***/ 21876: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -42036,7 +47160,7 @@ exports.requestLog = requestLog; /***/ }), -/***/ 68590: +/***/ 55601: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -43151,7 +48275,7 @@ exports.restEndpointMethods = restEndpointMethods; /***/ }), -/***/ 69980: +/***/ 17083: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43161,7 +48285,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } -var Bottleneck = _interopDefault(__nccwpck_require__(90058)); +var Bottleneck = _interopDefault(__nccwpck_require__(95439)); // @ts-ignore async function errorRequest(octokit, state, error, options) { @@ -43235,7 +48359,7 @@ exports.retry = retry; /***/ }), -/***/ 40857: +/***/ 10073: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43245,11 +48369,11 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } -var endpoint = __nccwpck_require__(28124); -var universalUserAgent = __nccwpck_require__(68636); -var isPlainObject = __nccwpck_require__(54132); -var nodeFetch = _interopDefault(__nccwpck_require__(96295)); -var requestError = __nccwpck_require__(37656); +var endpoint = __nccwpck_require__(25262); +var universalUserAgent = __nccwpck_require__(40996); +var isPlainObject = __nccwpck_require__(30655); +var nodeFetch = _interopDefault(__nccwpck_require__(35325)); +var requestError = __nccwpck_require__(40736); const VERSION = "5.6.3"; @@ -43420,7 +48544,7 @@ exports.request = request; /***/ }), -/***/ 37656: +/***/ 40736: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43430,8 +48554,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } -var deprecation = __nccwpck_require__(24107); -var once = _interopDefault(__nccwpck_require__(58203)); +var deprecation = __nccwpck_require__(26590); +var once = _interopDefault(__nccwpck_require__(55493)); const logOnceCode = once(deprecation => console.warn(deprecation)); const logOnceHeaders = once(deprecation => console.warn(deprecation)); @@ -43502,7 +48626,7 @@ exports.RequestError = RequestError; /***/ }), -/***/ 14593: +/***/ 6295: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43524,9 +48648,9 @@ exports.RequestError = RequestError; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ContextAPI = void 0; -const NoopContextManager_1 = __nccwpck_require__(18571); -const global_utils_1 = __nccwpck_require__(87638); -const diag_1 = __nccwpck_require__(71411); +const NoopContextManager_1 = __nccwpck_require__(42280); +const global_utils_1 = __nccwpck_require__(37144); +const diag_1 = __nccwpck_require__(82442); const API_NAME = 'context'; const NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager(); /** @@ -43590,7 +48714,7 @@ exports.ContextAPI = ContextAPI; /***/ }), -/***/ 71411: +/***/ 82442: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43612,10 +48736,10 @@ exports.ContextAPI = ContextAPI; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.DiagAPI = void 0; -const ComponentLogger_1 = __nccwpck_require__(84394); -const logLevelLogger_1 = __nccwpck_require__(89327); -const types_1 = __nccwpck_require__(39184); -const global_utils_1 = __nccwpck_require__(87638); +const ComponentLogger_1 = __nccwpck_require__(52222); +const logLevelLogger_1 = __nccwpck_require__(7734); +const types_1 = __nccwpck_require__(14695); +const global_utils_1 = __nccwpck_require__(37144); const API_NAME = 'diag'; /** * Singleton object which represents the entry point to the OpenTelemetry internal @@ -43690,7 +48814,7 @@ exports.DiagAPI = DiagAPI; /***/ }), -/***/ 43376: +/***/ 23113: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43712,9 +48836,9 @@ exports.DiagAPI = DiagAPI; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.MetricsAPI = void 0; -const NoopMeterProvider_1 = __nccwpck_require__(9976); -const global_utils_1 = __nccwpck_require__(87638); -const diag_1 = __nccwpck_require__(71411); +const NoopMeterProvider_1 = __nccwpck_require__(80604); +const global_utils_1 = __nccwpck_require__(37144); +const diag_1 = __nccwpck_require__(82442); const API_NAME = 'metrics'; /** * Singleton object which represents the entry point to the OpenTelemetry Metrics API @@ -43758,7 +48882,7 @@ exports.MetricsAPI = MetricsAPI; /***/ }), -/***/ 47827: +/***/ 37057: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43780,12 +48904,12 @@ exports.MetricsAPI = MetricsAPI; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.PropagationAPI = void 0; -const global_utils_1 = __nccwpck_require__(87638); -const NoopTextMapPropagator_1 = __nccwpck_require__(78807); -const TextMapPropagator_1 = __nccwpck_require__(75642); -const context_helpers_1 = __nccwpck_require__(380); -const utils_1 = __nccwpck_require__(97346); -const diag_1 = __nccwpck_require__(71411); +const global_utils_1 = __nccwpck_require__(37144); +const NoopTextMapPropagator_1 = __nccwpck_require__(58909); +const TextMapPropagator_1 = __nccwpck_require__(6496); +const context_helpers_1 = __nccwpck_require__(64801); +const utils_1 = __nccwpck_require__(33472); +const diag_1 = __nccwpck_require__(82442); const API_NAME = 'propagation'; const NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator(); /** @@ -43854,7 +48978,7 @@ exports.PropagationAPI = PropagationAPI; /***/ }), -/***/ 93743: +/***/ 45371: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43876,11 +49000,11 @@ exports.PropagationAPI = PropagationAPI; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.TraceAPI = void 0; -const global_utils_1 = __nccwpck_require__(87638); -const ProxyTracerProvider_1 = __nccwpck_require__(50344); -const spancontext_utils_1 = __nccwpck_require__(62966); -const context_utils_1 = __nccwpck_require__(4054); -const diag_1 = __nccwpck_require__(71411); +const global_utils_1 = __nccwpck_require__(37144); +const ProxyTracerProvider_1 = __nccwpck_require__(71310); +const spancontext_utils_1 = __nccwpck_require__(90273); +const context_utils_1 = __nccwpck_require__(63189); +const diag_1 = __nccwpck_require__(82442); const API_NAME = 'trace'; /** * Singleton object which represents the entry point to the OpenTelemetry Tracing API @@ -43940,7 +49064,7 @@ exports.TraceAPI = TraceAPI; /***/ }), -/***/ 380: +/***/ 64801: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -43962,8 +49086,8 @@ exports.TraceAPI = TraceAPI; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = void 0; -const context_1 = __nccwpck_require__(14593); -const context_2 = __nccwpck_require__(85316); +const context_1 = __nccwpck_require__(6295); +const context_2 = __nccwpck_require__(89109); /** * Baggage key */ @@ -44010,7 +49134,7 @@ exports.deleteBaggage = deleteBaggage; /***/ }), -/***/ 27061: +/***/ 49182: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44072,7 +49196,7 @@ exports.BaggageImpl = BaggageImpl; /***/ }), -/***/ 17248: +/***/ 31735: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44102,7 +49226,7 @@ exports.baggageEntryMetadataSymbol = Symbol('BaggageEntryMetadata'); /***/ }), -/***/ 97346: +/***/ 33472: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44124,9 +49248,9 @@ exports.baggageEntryMetadataSymbol = Symbol('BaggageEntryMetadata'); */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.baggageEntryMetadataFromString = exports.createBaggage = void 0; -const diag_1 = __nccwpck_require__(71411); -const baggage_impl_1 = __nccwpck_require__(27061); -const symbol_1 = __nccwpck_require__(17248); +const diag_1 = __nccwpck_require__(82442); +const baggage_impl_1 = __nccwpck_require__(49182); +const symbol_1 = __nccwpck_require__(31735); const diag = diag_1.DiagAPI.instance(); /** * Create a new Baggage with optional entries @@ -44160,7 +49284,7 @@ exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString; /***/ }), -/***/ 34382: +/***/ 49980: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44184,14 +49308,14 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.context = void 0; // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const context_1 = __nccwpck_require__(14593); +const context_1 = __nccwpck_require__(6295); /** Entrypoint for context API */ exports.context = context_1.ContextAPI.getInstance(); //# sourceMappingURL=context-api.js.map /***/ }), -/***/ 18571: +/***/ 42280: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44213,7 +49337,7 @@ exports.context = context_1.ContextAPI.getInstance(); */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.NoopContextManager = void 0; -const context_1 = __nccwpck_require__(85316); +const context_1 = __nccwpck_require__(89109); class NoopContextManager { active() { return context_1.ROOT_CONTEXT; @@ -44236,7 +49360,7 @@ exports.NoopContextManager = NoopContextManager; /***/ }), -/***/ 85316: +/***/ 89109: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44298,7 +49422,7 @@ exports.ROOT_CONTEXT = new BaseContext(); /***/ }), -/***/ 9586: +/***/ 81612: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44322,7 +49446,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.diag = void 0; // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const diag_1 = __nccwpck_require__(71411); +const diag_1 = __nccwpck_require__(82442); /** * Entrypoint for Diag API. * Defines Diagnostic handler used for internal diagnostic logging operations. @@ -44334,7 +49458,7 @@ exports.diag = diag_1.DiagAPI.instance(); /***/ }), -/***/ 84394: +/***/ 52222: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44356,7 +49480,7 @@ exports.diag = diag_1.DiagAPI.instance(); */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.DiagComponentLogger = void 0; -const global_utils_1 = __nccwpck_require__(87638); +const global_utils_1 = __nccwpck_require__(37144); /** * Component Logger which is meant to be used as part of any component which * will add automatically additional namespace in front of the log message. @@ -44400,7 +49524,7 @@ function logProxy(funcName, namespace, args) { /***/ }), -/***/ 12048: +/***/ 65766: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44464,7 +49588,7 @@ exports.DiagConsoleLogger = DiagConsoleLogger; /***/ }), -/***/ 89327: +/***/ 7734: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44486,7 +49610,7 @@ exports.DiagConsoleLogger = DiagConsoleLogger; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createLogLevelDiagLogger = void 0; -const types_1 = __nccwpck_require__(39184); +const types_1 = __nccwpck_require__(14695); function createLogLevelDiagLogger(maxLevel, logger) { if (maxLevel < types_1.DiagLogLevel.NONE) { maxLevel = types_1.DiagLogLevel.NONE; @@ -44516,7 +49640,7 @@ exports.createLogLevelDiagLogger = createLogLevelDiagLogger; /***/ }), -/***/ 39184: +/***/ 14695: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44567,7 +49691,7 @@ var DiagLogLevel; /***/ }), -/***/ 27742: +/***/ 9365: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44589,59 +49713,59 @@ var DiagLogLevel; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = void 0; -var utils_1 = __nccwpck_require__(97346); +var utils_1 = __nccwpck_require__(33472); Object.defineProperty(exports, "baggageEntryMetadataFromString", ({ enumerable: true, get: function () { return utils_1.baggageEntryMetadataFromString; } })); // Context APIs -var context_1 = __nccwpck_require__(85316); +var context_1 = __nccwpck_require__(89109); Object.defineProperty(exports, "createContextKey", ({ enumerable: true, get: function () { return context_1.createContextKey; } })); Object.defineProperty(exports, "ROOT_CONTEXT", ({ enumerable: true, get: function () { return context_1.ROOT_CONTEXT; } })); // Diag APIs -var consoleLogger_1 = __nccwpck_require__(12048); +var consoleLogger_1 = __nccwpck_require__(65766); Object.defineProperty(exports, "DiagConsoleLogger", ({ enumerable: true, get: function () { return consoleLogger_1.DiagConsoleLogger; } })); -var types_1 = __nccwpck_require__(39184); +var types_1 = __nccwpck_require__(14695); Object.defineProperty(exports, "DiagLogLevel", ({ enumerable: true, get: function () { return types_1.DiagLogLevel; } })); // Metrics APIs -var NoopMeter_1 = __nccwpck_require__(99535); +var NoopMeter_1 = __nccwpck_require__(14753); Object.defineProperty(exports, "createNoopMeter", ({ enumerable: true, get: function () { return NoopMeter_1.createNoopMeter; } })); -var Metric_1 = __nccwpck_require__(42414); +var Metric_1 = __nccwpck_require__(17533); Object.defineProperty(exports, "ValueType", ({ enumerable: true, get: function () { return Metric_1.ValueType; } })); // Propagation APIs -var TextMapPropagator_1 = __nccwpck_require__(75642); +var TextMapPropagator_1 = __nccwpck_require__(6496); Object.defineProperty(exports, "defaultTextMapGetter", ({ enumerable: true, get: function () { return TextMapPropagator_1.defaultTextMapGetter; } })); Object.defineProperty(exports, "defaultTextMapSetter", ({ enumerable: true, get: function () { return TextMapPropagator_1.defaultTextMapSetter; } })); -var ProxyTracer_1 = __nccwpck_require__(61360); +var ProxyTracer_1 = __nccwpck_require__(61840); Object.defineProperty(exports, "ProxyTracer", ({ enumerable: true, get: function () { return ProxyTracer_1.ProxyTracer; } })); -var ProxyTracerProvider_1 = __nccwpck_require__(50344); +var ProxyTracerProvider_1 = __nccwpck_require__(71310); Object.defineProperty(exports, "ProxyTracerProvider", ({ enumerable: true, get: function () { return ProxyTracerProvider_1.ProxyTracerProvider; } })); -var SamplingResult_1 = __nccwpck_require__(62026); +var SamplingResult_1 = __nccwpck_require__(45886); Object.defineProperty(exports, "SamplingDecision", ({ enumerable: true, get: function () { return SamplingResult_1.SamplingDecision; } })); -var span_kind_1 = __nccwpck_require__(32970); +var span_kind_1 = __nccwpck_require__(62147); Object.defineProperty(exports, "SpanKind", ({ enumerable: true, get: function () { return span_kind_1.SpanKind; } })); -var status_1 = __nccwpck_require__(65398); +var status_1 = __nccwpck_require__(54436); Object.defineProperty(exports, "SpanStatusCode", ({ enumerable: true, get: function () { return status_1.SpanStatusCode; } })); -var trace_flags_1 = __nccwpck_require__(96643); +var trace_flags_1 = __nccwpck_require__(79533); Object.defineProperty(exports, "TraceFlags", ({ enumerable: true, get: function () { return trace_flags_1.TraceFlags; } })); -var utils_2 = __nccwpck_require__(85649); +var utils_2 = __nccwpck_require__(29361); Object.defineProperty(exports, "createTraceState", ({ enumerable: true, get: function () { return utils_2.createTraceState; } })); -var spancontext_utils_1 = __nccwpck_require__(62966); +var spancontext_utils_1 = __nccwpck_require__(90273); Object.defineProperty(exports, "isSpanContextValid", ({ enumerable: true, get: function () { return spancontext_utils_1.isSpanContextValid; } })); Object.defineProperty(exports, "isValidTraceId", ({ enumerable: true, get: function () { return spancontext_utils_1.isValidTraceId; } })); Object.defineProperty(exports, "isValidSpanId", ({ enumerable: true, get: function () { return spancontext_utils_1.isValidSpanId; } })); -var invalid_span_constants_1 = __nccwpck_require__(29985); +var invalid_span_constants_1 = __nccwpck_require__(74027); Object.defineProperty(exports, "INVALID_SPANID", ({ enumerable: true, get: function () { return invalid_span_constants_1.INVALID_SPANID; } })); Object.defineProperty(exports, "INVALID_TRACEID", ({ enumerable: true, get: function () { return invalid_span_constants_1.INVALID_TRACEID; } })); Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", ({ enumerable: true, get: function () { return invalid_span_constants_1.INVALID_SPAN_CONTEXT; } })); // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const context_api_1 = __nccwpck_require__(34382); +const context_api_1 = __nccwpck_require__(49980); Object.defineProperty(exports, "context", ({ enumerable: true, get: function () { return context_api_1.context; } })); -const diag_api_1 = __nccwpck_require__(9586); +const diag_api_1 = __nccwpck_require__(81612); Object.defineProperty(exports, "diag", ({ enumerable: true, get: function () { return diag_api_1.diag; } })); -const metrics_api_1 = __nccwpck_require__(59837); +const metrics_api_1 = __nccwpck_require__(71921); Object.defineProperty(exports, "metrics", ({ enumerable: true, get: function () { return metrics_api_1.metrics; } })); -const propagation_api_1 = __nccwpck_require__(97338); +const propagation_api_1 = __nccwpck_require__(9084); Object.defineProperty(exports, "propagation", ({ enumerable: true, get: function () { return propagation_api_1.propagation; } })); -const trace_api_1 = __nccwpck_require__(18388); +const trace_api_1 = __nccwpck_require__(60551); Object.defineProperty(exports, "trace", ({ enumerable: true, get: function () { return trace_api_1.trace; } })); // Default export. exports["default"] = { @@ -44655,7 +49779,7 @@ exports["default"] = { /***/ }), -/***/ 87638: +/***/ 37144: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44677,9 +49801,9 @@ exports["default"] = { */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = void 0; -const platform_1 = __nccwpck_require__(55477); -const version_1 = __nccwpck_require__(93341); -const semver_1 = __nccwpck_require__(62720); +const platform_1 = __nccwpck_require__(52554); +const version_1 = __nccwpck_require__(59821); +const semver_1 = __nccwpck_require__(6047); const major = version_1.VERSION.split('.')[0]; const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`); const _global = platform_1._globalThis; @@ -44726,7 +49850,7 @@ exports.unregisterGlobal = unregisterGlobal; /***/ }), -/***/ 62720: +/***/ 6047: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44748,7 +49872,7 @@ exports.unregisterGlobal = unregisterGlobal; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isCompatible = exports._makeCompatibilityCheck = void 0; -const version_1 = __nccwpck_require__(93341); +const version_1 = __nccwpck_require__(59821); const re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/; /** * Create a function to test an API version to see if it is compatible with the provided ownVersion. @@ -44855,7 +49979,7 @@ exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION); /***/ }), -/***/ 59837: +/***/ 71921: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -44879,14 +50003,14 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.metrics = void 0; // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const metrics_1 = __nccwpck_require__(43376); +const metrics_1 = __nccwpck_require__(23113); /** Entrypoint for metrics API */ exports.metrics = metrics_1.MetricsAPI.getInstance(); //# sourceMappingURL=metrics-api.js.map /***/ }), -/***/ 42414: +/***/ 17533: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -44918,7 +50042,7 @@ var ValueType; /***/ }), -/***/ 99535: +/***/ 14753: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45041,7 +50165,7 @@ exports.createNoopMeter = createNoopMeter; /***/ }), -/***/ 9976: +/***/ 80604: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45063,7 +50187,7 @@ exports.createNoopMeter = createNoopMeter; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = void 0; -const NoopMeter_1 = __nccwpck_require__(99535); +const NoopMeter_1 = __nccwpck_require__(14753); /** * An implementation of the {@link MeterProvider} which returns an impotent Meter * for all calls to `getMeter` @@ -45079,7 +50203,7 @@ exports.NOOP_METER_PROVIDER = new NoopMeterProvider(); /***/ }), -/***/ 55477: +/***/ 52554: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -45110,12 +50234,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(31791), exports); +__exportStar(__nccwpck_require__(36127), exports); //# sourceMappingURL=index.js.map /***/ }), -/***/ 83450: +/***/ 55856: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45144,7 +50268,7 @@ exports._globalThis = typeof globalThis === 'object' ? globalThis : global; /***/ }), -/***/ 31791: +/***/ 36127: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -45175,12 +50299,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -__exportStar(__nccwpck_require__(83450), exports); +__exportStar(__nccwpck_require__(55856), exports); //# sourceMappingURL=index.js.map /***/ }), -/***/ 97338: +/***/ 9084: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45204,14 +50328,14 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.propagation = void 0; // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const propagation_1 = __nccwpck_require__(47827); +const propagation_1 = __nccwpck_require__(37057); /** Entrypoint for propagation API */ exports.propagation = propagation_1.PropagationAPI.getInstance(); //# sourceMappingURL=propagation-api.js.map /***/ }), -/***/ 78807: +/***/ 58909: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45252,7 +50376,7 @@ exports.NoopTextMapPropagator = NoopTextMapPropagator; /***/ }), -/***/ 75642: +/***/ 6496: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45300,7 +50424,7 @@ exports.defaultTextMapSetter = { /***/ }), -/***/ 18388: +/***/ 60551: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45324,14 +50448,14 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.trace = void 0; // Split module-level variable definition into separate files to allow // tree-shaking on each api instance. -const trace_1 = __nccwpck_require__(93743); +const trace_1 = __nccwpck_require__(45371); /** Entrypoint for trace API */ exports.trace = trace_1.TraceAPI.getInstance(); //# sourceMappingURL=trace-api.js.map /***/ }), -/***/ 26644: +/***/ 23070: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45353,7 +50477,7 @@ exports.trace = trace_1.TraceAPI.getInstance(); */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.NonRecordingSpan = void 0; -const invalid_span_constants_1 = __nccwpck_require__(29985); +const invalid_span_constants_1 = __nccwpck_require__(74027); /** * The NonRecordingSpan is the default {@link Span} that is used when no Span * implementation is available. All operations are no-op including context @@ -45401,7 +50525,7 @@ exports.NonRecordingSpan = NonRecordingSpan; /***/ }), -/***/ 10555: +/***/ 42054: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45423,10 +50547,10 @@ exports.NonRecordingSpan = NonRecordingSpan; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.NoopTracer = void 0; -const context_1 = __nccwpck_require__(14593); -const context_utils_1 = __nccwpck_require__(4054); -const NonRecordingSpan_1 = __nccwpck_require__(26644); -const spancontext_utils_1 = __nccwpck_require__(62966); +const context_1 = __nccwpck_require__(6295); +const context_utils_1 = __nccwpck_require__(63189); +const NonRecordingSpan_1 = __nccwpck_require__(23070); +const spancontext_utils_1 = __nccwpck_require__(90273); const contextApi = context_1.ContextAPI.getInstance(); /** * No-op implementations of {@link Tracer}. @@ -45483,7 +50607,7 @@ function isSpanContext(spanContext) { /***/ }), -/***/ 71498: +/***/ 91738: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45505,7 +50629,7 @@ function isSpanContext(spanContext) { */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.NoopTracerProvider = void 0; -const NoopTracer_1 = __nccwpck_require__(10555); +const NoopTracer_1 = __nccwpck_require__(42054); /** * An implementation of the {@link TracerProvider} which returns an impotent * Tracer for all calls to `getTracer`. @@ -45522,7 +50646,7 @@ exports.NoopTracerProvider = NoopTracerProvider; /***/ }), -/***/ 61360: +/***/ 61840: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45544,7 +50668,7 @@ exports.NoopTracerProvider = NoopTracerProvider; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ProxyTracer = void 0; -const NoopTracer_1 = __nccwpck_require__(10555); +const NoopTracer_1 = __nccwpck_require__(42054); const NOOP_TRACER = new NoopTracer_1.NoopTracer(); /** * Proxy tracer provided by the proxy tracer provider @@ -45584,7 +50708,7 @@ exports.ProxyTracer = ProxyTracer; /***/ }), -/***/ 50344: +/***/ 71310: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45606,8 +50730,8 @@ exports.ProxyTracer = ProxyTracer; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ProxyTracerProvider = void 0; -const ProxyTracer_1 = __nccwpck_require__(61360); -const NoopTracerProvider_1 = __nccwpck_require__(71498); +const ProxyTracer_1 = __nccwpck_require__(61840); +const NoopTracerProvider_1 = __nccwpck_require__(91738); const NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider(); /** * Tracer provider which provides {@link ProxyTracer}s. @@ -45645,7 +50769,7 @@ exports.ProxyTracerProvider = ProxyTracerProvider; /***/ }), -/***/ 62026: +/***/ 45886: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45694,7 +50818,7 @@ var SamplingDecision; /***/ }), -/***/ 4054: +/***/ 63189: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45716,9 +50840,9 @@ var SamplingDecision; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = void 0; -const context_1 = __nccwpck_require__(85316); -const NonRecordingSpan_1 = __nccwpck_require__(26644); -const context_2 = __nccwpck_require__(14593); +const context_1 = __nccwpck_require__(89109); +const NonRecordingSpan_1 = __nccwpck_require__(23070); +const context_2 = __nccwpck_require__(6295); /** * span key */ @@ -45783,7 +50907,7 @@ exports.getSpanContext = getSpanContext; /***/ }), -/***/ 90453: +/***/ 4420: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45805,7 +50929,7 @@ exports.getSpanContext = getSpanContext; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.TraceStateImpl = void 0; -const tracestate_validators_1 = __nccwpck_require__(45603); +const tracestate_validators_1 = __nccwpck_require__(5079); const MAX_TRACE_STATE_ITEMS = 32; const MAX_TRACE_STATE_LEN = 512; const LIST_MEMBERS_SEPARATOR = ','; @@ -45893,7 +51017,7 @@ exports.TraceStateImpl = TraceStateImpl; /***/ }), -/***/ 45603: +/***/ 5079: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -45946,7 +51070,7 @@ exports.validateValue = validateValue; /***/ }), -/***/ 85649: +/***/ 29361: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45968,7 +51092,7 @@ exports.validateValue = validateValue; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.createTraceState = void 0; -const tracestate_impl_1 = __nccwpck_require__(90453); +const tracestate_impl_1 = __nccwpck_require__(4420); function createTraceState(rawTraceState) { return new tracestate_impl_1.TraceStateImpl(rawTraceState); } @@ -45977,7 +51101,7 @@ exports.createTraceState = createTraceState; /***/ }), -/***/ 29985: +/***/ 74027: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -45999,7 +51123,7 @@ exports.createTraceState = createTraceState; */ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = void 0; -const trace_flags_1 = __nccwpck_require__(96643); +const trace_flags_1 = __nccwpck_require__(79533); exports.INVALID_SPANID = '0000000000000000'; exports.INVALID_TRACEID = '00000000000000000000000000000000'; exports.INVALID_SPAN_CONTEXT = { @@ -46011,7 +51135,7 @@ exports.INVALID_SPAN_CONTEXT = { /***/ }), -/***/ 32970: +/***/ 62147: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46064,7 +51188,7 @@ var SpanKind; /***/ }), -/***/ 62966: +/***/ 90273: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -46086,8 +51210,8 @@ exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = e * See the License for the specific language governing permissions and * limitations under the License. */ -const invalid_span_constants_1 = __nccwpck_require__(29985); -const NonRecordingSpan_1 = __nccwpck_require__(26644); +const invalid_span_constants_1 = __nccwpck_require__(74027); +const NonRecordingSpan_1 = __nccwpck_require__(23070); const VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i; const VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i; function isValidTraceId(traceId) { @@ -46120,7 +51244,7 @@ exports.wrapSpanContext = wrapSpanContext; /***/ }), -/***/ 65398: +/***/ 54436: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46150,7 +51274,7 @@ var SpanStatusCode; /***/ }), -/***/ 96643: +/***/ 79533: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46183,7 +51307,7 @@ var TraceFlags; /***/ }), -/***/ 93341: +/***/ 59821: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46211,7 +51335,7 @@ exports.VERSION = '1.4.1'; /***/ }), -/***/ 13694: +/***/ 90506: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -46269,7 +51393,7 @@ exports.ClientStreamingCall = ClientStreamingCall; /***/ }), -/***/ 52669: +/***/ 38078: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46363,7 +51487,7 @@ exports.Deferred = Deferred; /***/ }), -/***/ 89835: +/***/ 75118: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -46420,7 +51544,7 @@ exports.DuplexStreamingCall = DuplexStreamingCall; /***/ }), -/***/ 81745: +/***/ 34755: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -46429,51 +51553,51 @@ exports.DuplexStreamingCall = DuplexStreamingCall; // Note: we do not use `export * from ...` to help tree shakers, // webpack verbose output hints that this should be useful Object.defineProperty(exports, "__esModule", ({ value: true })); -var service_type_1 = __nccwpck_require__(89999); +var service_type_1 = __nccwpck_require__(54511); Object.defineProperty(exports, "ServiceType", ({ enumerable: true, get: function () { return service_type_1.ServiceType; } })); -var reflection_info_1 = __nccwpck_require__(83044); +var reflection_info_1 = __nccwpck_require__(68026); Object.defineProperty(exports, "readMethodOptions", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOptions; } })); Object.defineProperty(exports, "readMethodOption", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOption; } })); Object.defineProperty(exports, "readServiceOption", ({ enumerable: true, get: function () { return reflection_info_1.readServiceOption; } })); -var rpc_error_1 = __nccwpck_require__(73341); +var rpc_error_1 = __nccwpck_require__(44185); Object.defineProperty(exports, "RpcError", ({ enumerable: true, get: function () { return rpc_error_1.RpcError; } })); -var rpc_options_1 = __nccwpck_require__(26452); +var rpc_options_1 = __nccwpck_require__(4294); Object.defineProperty(exports, "mergeRpcOptions", ({ enumerable: true, get: function () { return rpc_options_1.mergeRpcOptions; } })); -var rpc_output_stream_1 = __nccwpck_require__(19221); +var rpc_output_stream_1 = __nccwpck_require__(27250); Object.defineProperty(exports, "RpcOutputStreamController", ({ enumerable: true, get: function () { return rpc_output_stream_1.RpcOutputStreamController; } })); -var test_transport_1 = __nccwpck_require__(89403); +var test_transport_1 = __nccwpck_require__(51610); Object.defineProperty(exports, "TestTransport", ({ enumerable: true, get: function () { return test_transport_1.TestTransport; } })); -var deferred_1 = __nccwpck_require__(52669); +var deferred_1 = __nccwpck_require__(38078); Object.defineProperty(exports, "Deferred", ({ enumerable: true, get: function () { return deferred_1.Deferred; } })); Object.defineProperty(exports, "DeferredState", ({ enumerable: true, get: function () { return deferred_1.DeferredState; } })); -var duplex_streaming_call_1 = __nccwpck_require__(89835); +var duplex_streaming_call_1 = __nccwpck_require__(75118); Object.defineProperty(exports, "DuplexStreamingCall", ({ enumerable: true, get: function () { return duplex_streaming_call_1.DuplexStreamingCall; } })); -var client_streaming_call_1 = __nccwpck_require__(13694); +var client_streaming_call_1 = __nccwpck_require__(90506); Object.defineProperty(exports, "ClientStreamingCall", ({ enumerable: true, get: function () { return client_streaming_call_1.ClientStreamingCall; } })); -var server_streaming_call_1 = __nccwpck_require__(37387); +var server_streaming_call_1 = __nccwpck_require__(18472); Object.defineProperty(exports, "ServerStreamingCall", ({ enumerable: true, get: function () { return server_streaming_call_1.ServerStreamingCall; } })); -var unary_call_1 = __nccwpck_require__(77727); +var unary_call_1 = __nccwpck_require__(56343); Object.defineProperty(exports, "UnaryCall", ({ enumerable: true, get: function () { return unary_call_1.UnaryCall; } })); -var rpc_interceptor_1 = __nccwpck_require__(61513); +var rpc_interceptor_1 = __nccwpck_require__(5730); Object.defineProperty(exports, "stackIntercept", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackIntercept; } })); Object.defineProperty(exports, "stackDuplexStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackDuplexStreamingInterceptors; } })); Object.defineProperty(exports, "stackClientStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackClientStreamingInterceptors; } })); Object.defineProperty(exports, "stackServerStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackServerStreamingInterceptors; } })); Object.defineProperty(exports, "stackUnaryInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackUnaryInterceptors; } })); -var server_call_context_1 = __nccwpck_require__(41449); +var server_call_context_1 = __nccwpck_require__(77475); Object.defineProperty(exports, "ServerCallContextController", ({ enumerable: true, get: function () { return server_call_context_1.ServerCallContextController; } })); /***/ }), -/***/ 83044: +/***/ 68026: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.readServiceOption = exports.readMethodOption = exports.readMethodOptions = exports.normalizeMethodInfo = void 0; -const runtime_1 = __nccwpck_require__(90076); +const runtime_1 = __nccwpck_require__(65204); /** * Turns PartialMethodInfo into MethodInfo. */ @@ -46531,7 +51655,7 @@ exports.readServiceOption = readServiceOption; /***/ }), -/***/ 73341: +/***/ 44185: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46575,14 +51699,14 @@ exports.RpcError = RpcError; /***/ }), -/***/ 61513: +/***/ 5730: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.stackDuplexStreamingInterceptors = exports.stackClientStreamingInterceptors = exports.stackServerStreamingInterceptors = exports.stackUnaryInterceptors = exports.stackIntercept = void 0; -const runtime_1 = __nccwpck_require__(90076); +const runtime_1 = __nccwpck_require__(65204); /** * Creates a "stack" of of all interceptors specified in the given `RpcOptions`. * Used by generated client implementations. @@ -46657,14 +51781,14 @@ exports.stackDuplexStreamingInterceptors = stackDuplexStreamingInterceptors; /***/ }), -/***/ 26452: +/***/ 4294: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.mergeRpcOptions = void 0; -const runtime_1 = __nccwpck_require__(90076); +const runtime_1 = __nccwpck_require__(65204); /** * Merges custom RPC options with defaults. Returns a new instance and keeps * the "defaults" and the "options" unmodified. @@ -46731,15 +51855,15 @@ function copy(a, into) { /***/ }), -/***/ 19221: +/***/ 27250: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.RpcOutputStreamController = void 0; -const deferred_1 = __nccwpck_require__(52669); -const runtime_1 = __nccwpck_require__(90076); +const deferred_1 = __nccwpck_require__(38078); +const runtime_1 = __nccwpck_require__(65204); /** * A `RpcOutputStream` that you control. */ @@ -46911,7 +52035,7 @@ exports.RpcOutputStreamController = RpcOutputStreamController; /***/ }), -/***/ 41449: +/***/ 77475: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -46979,7 +52103,7 @@ exports.ServerCallContextController = ServerCallContextController; /***/ }), -/***/ 37387: +/***/ 18472: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -47037,14 +52161,14 @@ exports.ServerStreamingCall = ServerStreamingCall; /***/ }), -/***/ 89999: +/***/ 54511: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ServiceType = void 0; -const reflection_info_1 = __nccwpck_require__(83044); +const reflection_info_1 = __nccwpck_require__(68026); class ServiceType { constructor(typeName, methods, options) { this.typeName = typeName; @@ -47057,7 +52181,7 @@ exports.ServiceType = ServiceType; /***/ }), -/***/ 89403: +/***/ 51610: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -47073,14 +52197,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.TestTransport = void 0; -const rpc_error_1 = __nccwpck_require__(73341); -const runtime_1 = __nccwpck_require__(90076); -const rpc_output_stream_1 = __nccwpck_require__(19221); -const rpc_options_1 = __nccwpck_require__(26452); -const unary_call_1 = __nccwpck_require__(77727); -const server_streaming_call_1 = __nccwpck_require__(37387); -const client_streaming_call_1 = __nccwpck_require__(13694); -const duplex_streaming_call_1 = __nccwpck_require__(89835); +const rpc_error_1 = __nccwpck_require__(44185); +const runtime_1 = __nccwpck_require__(65204); +const rpc_output_stream_1 = __nccwpck_require__(27250); +const rpc_options_1 = __nccwpck_require__(4294); +const unary_call_1 = __nccwpck_require__(56343); +const server_streaming_call_1 = __nccwpck_require__(18472); +const client_streaming_call_1 = __nccwpck_require__(90506); +const duplex_streaming_call_1 = __nccwpck_require__(75118); /** * Transport for testing. */ @@ -47386,7 +52510,7 @@ class TestInputStream { /***/ }), -/***/ 77727: +/***/ 56343: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -47443,7 +52567,7 @@ exports.UnaryCall = UnaryCall; /***/ }), -/***/ 67516: +/***/ 99528: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -47494,7 +52618,7 @@ exports.assertFloat32 = assertFloat32; /***/ }), -/***/ 54402: +/***/ 22550: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -47620,7 +52744,7 @@ exports.base64encode = base64encode; /***/ }), -/***/ 22646: +/***/ 17919: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -47728,16 +52852,16 @@ var WireType; /***/ }), -/***/ 76442: +/***/ 85524: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BinaryReader = exports.binaryReadOptions = void 0; -const binary_format_contract_1 = __nccwpck_require__(22646); -const pb_long_1 = __nccwpck_require__(98953); -const goog_varint_1 = __nccwpck_require__(27326); +const binary_format_contract_1 = __nccwpck_require__(17919); +const pb_long_1 = __nccwpck_require__(18910); +const goog_varint_1 = __nccwpck_require__(24451); const defaultsRead = { readUnknownField: true, readerFactory: bytes => new BinaryReader(bytes), @@ -47919,16 +53043,16 @@ exports.BinaryReader = BinaryReader; /***/ }), -/***/ 65469: +/***/ 40070: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.BinaryWriter = exports.binaryWriteOptions = void 0; -const pb_long_1 = __nccwpck_require__(98953); -const goog_varint_1 = __nccwpck_require__(27326); -const assert_1 = __nccwpck_require__(67516); +const pb_long_1 = __nccwpck_require__(18910); +const goog_varint_1 = __nccwpck_require__(24451); +const assert_1 = __nccwpck_require__(99528); const defaultsWrite = { writeUnknownFields: true, writerFactory: () => new BinaryWriter(), @@ -48159,7 +53283,7 @@ exports.BinaryWriter = BinaryWriter; /***/ }), -/***/ 3389: +/***/ 88836: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48254,7 +53378,7 @@ exports.listEnumNumbers = listEnumNumbers; /***/ }), -/***/ 27326: +/***/ 24451: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48536,7 +53660,7 @@ exports.varint32read = varint32read; /***/ }), -/***/ 90076: +/***/ 65204: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -48546,46 +53670,46 @@ exports.varint32read = varint32read; // webpack verbose output hints that this should be useful Object.defineProperty(exports, "__esModule", ({ value: true })); // Convenience JSON typings and corresponding type guards -var json_typings_1 = __nccwpck_require__(93522); +var json_typings_1 = __nccwpck_require__(79499); Object.defineProperty(exports, "typeofJsonValue", ({ enumerable: true, get: function () { return json_typings_1.typeofJsonValue; } })); Object.defineProperty(exports, "isJsonObject", ({ enumerable: true, get: function () { return json_typings_1.isJsonObject; } })); // Base 64 encoding -var base64_1 = __nccwpck_require__(54402); +var base64_1 = __nccwpck_require__(22550); Object.defineProperty(exports, "base64decode", ({ enumerable: true, get: function () { return base64_1.base64decode; } })); Object.defineProperty(exports, "base64encode", ({ enumerable: true, get: function () { return base64_1.base64encode; } })); // UTF8 encoding -var protobufjs_utf8_1 = __nccwpck_require__(63626); +var protobufjs_utf8_1 = __nccwpck_require__(33688); Object.defineProperty(exports, "utf8read", ({ enumerable: true, get: function () { return protobufjs_utf8_1.utf8read; } })); // Binary format contracts, options for reading and writing, for example -var binary_format_contract_1 = __nccwpck_require__(22646); +var binary_format_contract_1 = __nccwpck_require__(17919); Object.defineProperty(exports, "WireType", ({ enumerable: true, get: function () { return binary_format_contract_1.WireType; } })); Object.defineProperty(exports, "mergeBinaryOptions", ({ enumerable: true, get: function () { return binary_format_contract_1.mergeBinaryOptions; } })); Object.defineProperty(exports, "UnknownFieldHandler", ({ enumerable: true, get: function () { return binary_format_contract_1.UnknownFieldHandler; } })); // Standard IBinaryReader implementation -var binary_reader_1 = __nccwpck_require__(76442); +var binary_reader_1 = __nccwpck_require__(85524); Object.defineProperty(exports, "BinaryReader", ({ enumerable: true, get: function () { return binary_reader_1.BinaryReader; } })); Object.defineProperty(exports, "binaryReadOptions", ({ enumerable: true, get: function () { return binary_reader_1.binaryReadOptions; } })); // Standard IBinaryWriter implementation -var binary_writer_1 = __nccwpck_require__(65469); +var binary_writer_1 = __nccwpck_require__(40070); Object.defineProperty(exports, "BinaryWriter", ({ enumerable: true, get: function () { return binary_writer_1.BinaryWriter; } })); Object.defineProperty(exports, "binaryWriteOptions", ({ enumerable: true, get: function () { return binary_writer_1.binaryWriteOptions; } })); // Int64 and UInt64 implementations required for the binary format -var pb_long_1 = __nccwpck_require__(98953); +var pb_long_1 = __nccwpck_require__(18910); Object.defineProperty(exports, "PbLong", ({ enumerable: true, get: function () { return pb_long_1.PbLong; } })); Object.defineProperty(exports, "PbULong", ({ enumerable: true, get: function () { return pb_long_1.PbULong; } })); // JSON format contracts, options for reading and writing, for example -var json_format_contract_1 = __nccwpck_require__(44025); +var json_format_contract_1 = __nccwpck_require__(78851); Object.defineProperty(exports, "jsonReadOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonReadOptions; } })); Object.defineProperty(exports, "jsonWriteOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonWriteOptions; } })); Object.defineProperty(exports, "mergeJsonOptions", ({ enumerable: true, get: function () { return json_format_contract_1.mergeJsonOptions; } })); // Message type contract -var message_type_contract_1 = __nccwpck_require__(42658); +var message_type_contract_1 = __nccwpck_require__(48666); Object.defineProperty(exports, "MESSAGE_TYPE", ({ enumerable: true, get: function () { return message_type_contract_1.MESSAGE_TYPE; } })); // Message type implementation via reflection -var message_type_1 = __nccwpck_require__(64469); +var message_type_1 = __nccwpck_require__(11209); Object.defineProperty(exports, "MessageType", ({ enumerable: true, get: function () { return message_type_1.MessageType; } })); // Reflection info, generated by the plugin, exposed to the user, used by reflection ops -var reflection_info_1 = __nccwpck_require__(56095); +var reflection_info_1 = __nccwpck_require__(12657); Object.defineProperty(exports, "ScalarType", ({ enumerable: true, get: function () { return reflection_info_1.ScalarType; } })); Object.defineProperty(exports, "LongType", ({ enumerable: true, get: function () { return reflection_info_1.LongType; } })); Object.defineProperty(exports, "RepeatType", ({ enumerable: true, get: function () { return reflection_info_1.RepeatType; } })); @@ -48594,44 +53718,44 @@ Object.defineProperty(exports, "readFieldOptions", ({ enumerable: true, get: fun Object.defineProperty(exports, "readFieldOption", ({ enumerable: true, get: function () { return reflection_info_1.readFieldOption; } })); Object.defineProperty(exports, "readMessageOption", ({ enumerable: true, get: function () { return reflection_info_1.readMessageOption; } })); // Message operations via reflection -var reflection_type_check_1 = __nccwpck_require__(26308); +var reflection_type_check_1 = __nccwpck_require__(78995); Object.defineProperty(exports, "ReflectionTypeCheck", ({ enumerable: true, get: function () { return reflection_type_check_1.ReflectionTypeCheck; } })); -var reflection_create_1 = __nccwpck_require__(21293); +var reflection_create_1 = __nccwpck_require__(98542); Object.defineProperty(exports, "reflectionCreate", ({ enumerable: true, get: function () { return reflection_create_1.reflectionCreate; } })); -var reflection_scalar_default_1 = __nccwpck_require__(83353); +var reflection_scalar_default_1 = __nccwpck_require__(96632); Object.defineProperty(exports, "reflectionScalarDefault", ({ enumerable: true, get: function () { return reflection_scalar_default_1.reflectionScalarDefault; } })); -var reflection_merge_partial_1 = __nccwpck_require__(88546); +var reflection_merge_partial_1 = __nccwpck_require__(20587); Object.defineProperty(exports, "reflectionMergePartial", ({ enumerable: true, get: function () { return reflection_merge_partial_1.reflectionMergePartial; } })); -var reflection_equals_1 = __nccwpck_require__(36028); +var reflection_equals_1 = __nccwpck_require__(88792); Object.defineProperty(exports, "reflectionEquals", ({ enumerable: true, get: function () { return reflection_equals_1.reflectionEquals; } })); -var reflection_binary_reader_1 = __nccwpck_require__(51575); +var reflection_binary_reader_1 = __nccwpck_require__(7767); Object.defineProperty(exports, "ReflectionBinaryReader", ({ enumerable: true, get: function () { return reflection_binary_reader_1.ReflectionBinaryReader; } })); -var reflection_binary_writer_1 = __nccwpck_require__(78539); +var reflection_binary_writer_1 = __nccwpck_require__(21915); Object.defineProperty(exports, "ReflectionBinaryWriter", ({ enumerable: true, get: function () { return reflection_binary_writer_1.ReflectionBinaryWriter; } })); -var reflection_json_reader_1 = __nccwpck_require__(31222); +var reflection_json_reader_1 = __nccwpck_require__(44125); Object.defineProperty(exports, "ReflectionJsonReader", ({ enumerable: true, get: function () { return reflection_json_reader_1.ReflectionJsonReader; } })); -var reflection_json_writer_1 = __nccwpck_require__(58041); +var reflection_json_writer_1 = __nccwpck_require__(25309); Object.defineProperty(exports, "ReflectionJsonWriter", ({ enumerable: true, get: function () { return reflection_json_writer_1.ReflectionJsonWriter; } })); -var reflection_contains_message_type_1 = __nccwpck_require__(27892); +var reflection_contains_message_type_1 = __nccwpck_require__(69465); Object.defineProperty(exports, "containsMessageType", ({ enumerable: true, get: function () { return reflection_contains_message_type_1.containsMessageType; } })); // Oneof helpers -var oneof_1 = __nccwpck_require__(41938); +var oneof_1 = __nccwpck_require__(68007); Object.defineProperty(exports, "isOneofGroup", ({ enumerable: true, get: function () { return oneof_1.isOneofGroup; } })); Object.defineProperty(exports, "setOneofValue", ({ enumerable: true, get: function () { return oneof_1.setOneofValue; } })); Object.defineProperty(exports, "getOneofValue", ({ enumerable: true, get: function () { return oneof_1.getOneofValue; } })); Object.defineProperty(exports, "clearOneofValue", ({ enumerable: true, get: function () { return oneof_1.clearOneofValue; } })); Object.defineProperty(exports, "getSelectedOneofValue", ({ enumerable: true, get: function () { return oneof_1.getSelectedOneofValue; } })); // Enum object type guard and reflection util, may be interesting to the user. -var enum_object_1 = __nccwpck_require__(3389); +var enum_object_1 = __nccwpck_require__(88836); Object.defineProperty(exports, "listEnumValues", ({ enumerable: true, get: function () { return enum_object_1.listEnumValues; } })); Object.defineProperty(exports, "listEnumNames", ({ enumerable: true, get: function () { return enum_object_1.listEnumNames; } })); Object.defineProperty(exports, "listEnumNumbers", ({ enumerable: true, get: function () { return enum_object_1.listEnumNumbers; } })); Object.defineProperty(exports, "isEnumObject", ({ enumerable: true, get: function () { return enum_object_1.isEnumObject; } })); // lowerCamelCase() is exported for plugin, rpc-runtime and other rpc packages -var lower_camel_case_1 = __nccwpck_require__(35301); +var lower_camel_case_1 = __nccwpck_require__(85922); Object.defineProperty(exports, "lowerCamelCase", ({ enumerable: true, get: function () { return lower_camel_case_1.lowerCamelCase; } })); // assertion functions are exported for plugin, may also be useful to user -var assert_1 = __nccwpck_require__(67516); +var assert_1 = __nccwpck_require__(99528); Object.defineProperty(exports, "assert", ({ enumerable: true, get: function () { return assert_1.assert; } })); Object.defineProperty(exports, "assertNever", ({ enumerable: true, get: function () { return assert_1.assertNever; } })); Object.defineProperty(exports, "assertInt32", ({ enumerable: true, get: function () { return assert_1.assertInt32; } })); @@ -48641,7 +53765,7 @@ Object.defineProperty(exports, "assertFloat32", ({ enumerable: true, get: functi /***/ }), -/***/ 44025: +/***/ 78851: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48684,7 +53808,7 @@ exports.mergeJsonOptions = mergeJsonOptions; /***/ }), -/***/ 93522: +/***/ 79499: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48717,7 +53841,7 @@ exports.isJsonObject = isJsonObject; /***/ }), -/***/ 35301: +/***/ 85922: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48760,7 +53884,7 @@ exports.lowerCamelCase = lowerCamelCase; /***/ }), -/***/ 42658: +/***/ 48666: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -48778,26 +53902,26 @@ exports.MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type"); /***/ }), -/***/ 64469: +/***/ 11209: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.MessageType = void 0; -const reflection_info_1 = __nccwpck_require__(56095); -const reflection_type_check_1 = __nccwpck_require__(26308); -const reflection_json_reader_1 = __nccwpck_require__(31222); -const reflection_json_writer_1 = __nccwpck_require__(58041); -const reflection_binary_reader_1 = __nccwpck_require__(51575); -const reflection_binary_writer_1 = __nccwpck_require__(78539); -const reflection_create_1 = __nccwpck_require__(21293); -const reflection_merge_partial_1 = __nccwpck_require__(88546); -const json_typings_1 = __nccwpck_require__(93522); -const json_format_contract_1 = __nccwpck_require__(44025); -const reflection_equals_1 = __nccwpck_require__(36028); -const binary_writer_1 = __nccwpck_require__(65469); -const binary_reader_1 = __nccwpck_require__(76442); +const reflection_info_1 = __nccwpck_require__(12657); +const reflection_type_check_1 = __nccwpck_require__(78995); +const reflection_json_reader_1 = __nccwpck_require__(44125); +const reflection_json_writer_1 = __nccwpck_require__(25309); +const reflection_binary_reader_1 = __nccwpck_require__(7767); +const reflection_binary_writer_1 = __nccwpck_require__(21915); +const reflection_create_1 = __nccwpck_require__(98542); +const reflection_merge_partial_1 = __nccwpck_require__(20587); +const json_typings_1 = __nccwpck_require__(79499); +const json_format_contract_1 = __nccwpck_require__(78851); +const reflection_equals_1 = __nccwpck_require__(88792); +const binary_writer_1 = __nccwpck_require__(40070); +const binary_reader_1 = __nccwpck_require__(85524); /** * This standard message type provides reflection-based * operations to work with a message. @@ -48958,7 +54082,7 @@ exports.MessageType = MessageType; /***/ }), -/***/ 41938: +/***/ 68007: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -49080,14 +54204,14 @@ exports.getSelectedOneofValue = getSelectedOneofValue; /***/ }), -/***/ 98953: +/***/ 18910: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.PbLong = exports.PbULong = exports.detectBi = void 0; -const goog_varint_1 = __nccwpck_require__(27326); +const goog_varint_1 = __nccwpck_require__(24451); let BI; function detectBi() { const dv = new DataView(new ArrayBuffer(8)); @@ -49326,7 +54450,7 @@ PbLong.ZERO = new PbLong(0, 0); /***/ }), -/***/ 63626: +/***/ 33688: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -49409,17 +54533,17 @@ exports.utf8read = utf8read; /***/ }), -/***/ 51575: +/***/ 7767: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ReflectionBinaryReader = void 0; -const binary_format_contract_1 = __nccwpck_require__(22646); -const reflection_info_1 = __nccwpck_require__(56095); -const reflection_long_convert_1 = __nccwpck_require__(32949); -const reflection_scalar_default_1 = __nccwpck_require__(83353); +const binary_format_contract_1 = __nccwpck_require__(17919); +const reflection_info_1 = __nccwpck_require__(12657); +const reflection_long_convert_1 = __nccwpck_require__(30554); +const reflection_scalar_default_1 = __nccwpck_require__(96632); /** * Reads proto3 messages in binary format using reflection information. * @@ -49600,17 +54724,17 @@ exports.ReflectionBinaryReader = ReflectionBinaryReader; /***/ }), -/***/ 78539: +/***/ 21915: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ReflectionBinaryWriter = void 0; -const binary_format_contract_1 = __nccwpck_require__(22646); -const reflection_info_1 = __nccwpck_require__(56095); -const assert_1 = __nccwpck_require__(67516); -const pb_long_1 = __nccwpck_require__(98953); +const binary_format_contract_1 = __nccwpck_require__(17919); +const reflection_info_1 = __nccwpck_require__(12657); +const assert_1 = __nccwpck_require__(99528); +const pb_long_1 = __nccwpck_require__(18910); /** * Writes proto3 messages in binary format using reflection information. * @@ -49841,14 +54965,14 @@ exports.ReflectionBinaryWriter = ReflectionBinaryWriter; /***/ }), -/***/ 27892: +/***/ 69465: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.containsMessageType = void 0; -const message_type_contract_1 = __nccwpck_require__(42658); +const message_type_contract_1 = __nccwpck_require__(48666); /** * Check if the provided object is a proto message. * @@ -49863,15 +54987,15 @@ exports.containsMessageType = containsMessageType; /***/ }), -/***/ 21293: +/***/ 98542: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.reflectionCreate = void 0; -const reflection_scalar_default_1 = __nccwpck_require__(83353); -const message_type_contract_1 = __nccwpck_require__(42658); +const reflection_scalar_default_1 = __nccwpck_require__(96632); +const message_type_contract_1 = __nccwpck_require__(48666); /** * Creates an instance of the generic message, using the field * information. @@ -49908,14 +55032,14 @@ exports.reflectionCreate = reflectionCreate; /***/ }), -/***/ 36028: +/***/ 88792: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.reflectionEquals = void 0; -const reflection_info_1 = __nccwpck_require__(56095); +const reflection_info_1 = __nccwpck_require__(12657); /** * Determines whether two message of the same type have the same field values. * Checks for deep equality, traversing repeated fields, oneof groups, maps @@ -49993,14 +55117,14 @@ function repeatedMsgEq(type, a, b) { /***/ }), -/***/ 56095: +/***/ 12657: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.readMessageOption = exports.readFieldOption = exports.readFieldOptions = exports.normalizeFieldInfo = exports.RepeatType = exports.LongType = exports.ScalarType = void 0; -const lower_camel_case_1 = __nccwpck_require__(35301); +const lower_camel_case_1 = __nccwpck_require__(85922); /** * Scalar value types. This is a subset of field types declared by protobuf * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE @@ -50159,19 +55283,19 @@ exports.readMessageOption = readMessageOption; /***/ }), -/***/ 31222: +/***/ 44125: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ReflectionJsonReader = void 0; -const json_typings_1 = __nccwpck_require__(93522); -const base64_1 = __nccwpck_require__(54402); -const reflection_info_1 = __nccwpck_require__(56095); -const pb_long_1 = __nccwpck_require__(98953); -const assert_1 = __nccwpck_require__(67516); -const reflection_long_convert_1 = __nccwpck_require__(32949); +const json_typings_1 = __nccwpck_require__(79499); +const base64_1 = __nccwpck_require__(22550); +const reflection_info_1 = __nccwpck_require__(12657); +const pb_long_1 = __nccwpck_require__(18910); +const assert_1 = __nccwpck_require__(99528); +const reflection_long_convert_1 = __nccwpck_require__(30554); /** * Reads proto3 messages in canonical JSON format using reflection information. * @@ -50480,17 +55604,17 @@ exports.ReflectionJsonReader = ReflectionJsonReader; /***/ }), -/***/ 58041: +/***/ 25309: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ReflectionJsonWriter = void 0; -const base64_1 = __nccwpck_require__(54402); -const pb_long_1 = __nccwpck_require__(98953); -const reflection_info_1 = __nccwpck_require__(56095); -const assert_1 = __nccwpck_require__(67516); +const base64_1 = __nccwpck_require__(22550); +const pb_long_1 = __nccwpck_require__(18910); +const reflection_info_1 = __nccwpck_require__(12657); +const assert_1 = __nccwpck_require__(99528); /** * Writes proto3 messages in canonical JSON format using reflection * information. @@ -50718,14 +55842,14 @@ exports.ReflectionJsonWriter = ReflectionJsonWriter; /***/ }), -/***/ 32949: +/***/ 30554: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.reflectionLongConvert = void 0; -const reflection_info_1 = __nccwpck_require__(56095); +const reflection_info_1 = __nccwpck_require__(12657); /** * Utility method to convert a PbLong or PbUlong to a JavaScript * representation during runtime. @@ -50750,7 +55874,7 @@ exports.reflectionLongConvert = reflectionLongConvert; /***/ }), -/***/ 88546: +/***/ 20587: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -50848,16 +55972,16 @@ exports.reflectionMergePartial = reflectionMergePartial; /***/ }), -/***/ 83353: +/***/ 96632: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.reflectionScalarDefault = void 0; -const reflection_info_1 = __nccwpck_require__(56095); -const reflection_long_convert_1 = __nccwpck_require__(32949); -const pb_long_1 = __nccwpck_require__(98953); +const reflection_info_1 = __nccwpck_require__(12657); +const reflection_long_convert_1 = __nccwpck_require__(30554); +const pb_long_1 = __nccwpck_require__(18910); /** * Creates the default value for a scalar type. */ @@ -50893,15 +56017,15 @@ exports.reflectionScalarDefault = reflectionScalarDefault; /***/ }), -/***/ 26308: +/***/ 78995: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.ReflectionTypeCheck = void 0; -const reflection_info_1 = __nccwpck_require__(56095); -const oneof_1 = __nccwpck_require__(41938); +const reflection_info_1 = __nccwpck_require__(12657); +const oneof_1 = __nccwpck_require__(68007); // noinspection JSMethodCanBeStatic class ReflectionTypeCheck { constructor(info) { @@ -51131,7 +56255,7 @@ exports.ReflectionTypeCheck = ReflectionTypeCheck; /***/ }), -/***/ 85982: +/***/ 69949: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -51141,15 +56265,15 @@ exports.ReflectionTypeCheck = ReflectionTypeCheck; * Licensed under the MIT license. * https://github.com/archiverjs/node-archiver/blob/master/LICENSE-MIT */ -var fs = __nccwpck_require__(91468); +var fs = __nccwpck_require__(80759); var path = __nccwpck_require__(71017); -var flatten = __nccwpck_require__(25402); -var difference = __nccwpck_require__(23651); -var union = __nccwpck_require__(76640); -var isPlainObject = __nccwpck_require__(98466); +var flatten = __nccwpck_require__(14926); +var difference = __nccwpck_require__(53229); +var union = __nccwpck_require__(13643); +var isPlainObject = __nccwpck_require__(94507); -var glob = __nccwpck_require__(3661); +var glob = __nccwpck_require__(19830); var file = module.exports = {}; @@ -51347,7 +56471,7 @@ file.normalizeFilesArray = function(data) { /***/ }), -/***/ 9925: +/***/ 80017: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -51357,18 +56481,18 @@ file.normalizeFilesArray = function(data) { * Licensed under the MIT license. * https://github.com/archiverjs/archiver-utils/blob/master/LICENSE */ -var fs = __nccwpck_require__(91468); +var fs = __nccwpck_require__(80759); var path = __nccwpck_require__(71017); var nutil = __nccwpck_require__(73837); -var lazystream = __nccwpck_require__(9936); -var normalizePath = __nccwpck_require__(19796); -var defaults = __nccwpck_require__(14285); +var lazystream = __nccwpck_require__(14137); +var normalizePath = __nccwpck_require__(38735); +var defaults = __nccwpck_require__(53703); var Stream = (__nccwpck_require__(12781).Stream); -var PassThrough = (__nccwpck_require__(93130).PassThrough); +var PassThrough = (__nccwpck_require__(51193).PassThrough); var utils = module.exports = {}; -utils.file = __nccwpck_require__(85982); +utils.file = __nccwpck_require__(69949); function assertPath(path) { if (typeof path !== 'string') { @@ -51510,7 +56634,7 @@ utils.walkdir = function(dirpath, base, callback) { /***/ }), -/***/ 57607: +/***/ 76356: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -51544,7 +56668,7 @@ utils.walkdir = function(dirpath, base, callback) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ /**/ @@ -51559,12 +56683,12 @@ var objectKeys = Object.keys || function (obj) { module.exports = Duplex; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ -var Readable = __nccwpck_require__(63037); -var Writable = __nccwpck_require__(51080); +var Readable = __nccwpck_require__(7522); +var Writable = __nccwpck_require__(10809); util.inherits(Duplex, Readable); @@ -51648,7 +56772,7 @@ Duplex.prototype._destroy = function (err, cb) { /***/ }), -/***/ 63656: +/***/ 50524: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -51681,11 +56805,11 @@ Duplex.prototype._destroy = function (err, cb) { module.exports = PassThrough; -var Transform = __nccwpck_require__(79994); +var Transform = __nccwpck_require__(89539); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(PassThrough, Transform); @@ -51702,7 +56826,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 63037: +/***/ 7522: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -51731,13 +56855,13 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Readable; /**/ -var isArray = __nccwpck_require__(80456); +var isArray = __nccwpck_require__(77751); /**/ /**/ @@ -51755,12 +56879,12 @@ var EElistenerCount = function (emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(33182); +var Stream = __nccwpck_require__(54579); /**/ /**/ -var Buffer = (__nccwpck_require__(37514).Buffer); +var Buffer = (__nccwpck_require__(35240).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -51772,8 +56896,8 @@ function _isUint8Array(obj) { /**/ /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ @@ -51786,8 +56910,8 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(64194); -var destroyImpl = __nccwpck_require__(37421); +var BufferList = __nccwpck_require__(63399); +var destroyImpl = __nccwpck_require__(64634); var StringDecoder; util.inherits(Readable, Stream); @@ -51807,7 +56931,7 @@ function prependListener(emitter, event, fn) { } function ReadableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(57607); + Duplex = Duplex || __nccwpck_require__(76356); options = options || {}; @@ -51877,14 +57001,14 @@ function ReadableState(options, stream) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(50823)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(17337)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(57607); + Duplex = Duplex || __nccwpck_require__(76356); if (!(this instanceof Readable)) return new Readable(options); @@ -52033,7 +57157,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(50823)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(17337)/* .StringDecoder */ .s); this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; @@ -52728,7 +57852,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 79994: +/***/ 89539: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -52799,11 +57923,11 @@ function indexOf(xs, x) { module.exports = Transform; -var Duplex = __nccwpck_require__(57607); +var Duplex = __nccwpck_require__(76356); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(Transform, Duplex); @@ -52949,7 +58073,7 @@ function done(stream, er, data) { /***/ }), -/***/ 51080: +/***/ 10809: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -52982,7 +58106,7 @@ function done(stream, er, data) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Writable; @@ -53019,23 +58143,23 @@ var Duplex; Writable.WritableState = WritableState; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ var internalUtil = { - deprecate: __nccwpck_require__(98485) + deprecate: __nccwpck_require__(20524) }; /**/ /**/ -var Stream = __nccwpck_require__(33182); +var Stream = __nccwpck_require__(54579); /**/ /**/ -var Buffer = (__nccwpck_require__(37514).Buffer); +var Buffer = (__nccwpck_require__(35240).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -53046,14 +58170,14 @@ function _isUint8Array(obj) { /**/ -var destroyImpl = __nccwpck_require__(37421); +var destroyImpl = __nccwpck_require__(64634); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(57607); + Duplex = Duplex || __nccwpck_require__(76356); options = options || {}; @@ -53203,7 +58327,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(57607); + Duplex = Duplex || __nccwpck_require__(76356); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -53641,7 +58765,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 64194: +/***/ 63399: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -53649,7 +58773,7 @@ Writable.prototype._destroy = function (err, cb) { function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var Buffer = (__nccwpck_require__(37514).Buffer); +var Buffer = (__nccwpck_require__(35240).Buffer); var util = __nccwpck_require__(73837); function copyBuffer(src, target, offset) { @@ -53726,7 +58850,7 @@ if (util && util.inspect && util.inspect.custom) { /***/ }), -/***/ 37421: +/***/ 64634: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -53734,7 +58858,7 @@ if (util && util.inspect && util.inspect.custom) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ // undocumented cb() API, needed for core, not for public API @@ -53817,7 +58941,7 @@ module.exports = { /***/ }), -/***/ 33182: +/***/ 54579: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -53825,7 +58949,7 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 93130: +/***/ 51193: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -53839,19 +58963,19 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { exports.PassThrough = Stream.PassThrough; exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(63037); + exports = module.exports = __nccwpck_require__(7522); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(51080); - exports.Duplex = __nccwpck_require__(57607); - exports.Transform = __nccwpck_require__(79994); - exports.PassThrough = __nccwpck_require__(63656); + exports.Writable = __nccwpck_require__(10809); + exports.Duplex = __nccwpck_require__(76356); + exports.Transform = __nccwpck_require__(89539); + exports.PassThrough = __nccwpck_require__(50524); } /***/ }), -/***/ 37514: +/***/ 35240: /***/ ((module, exports, __nccwpck_require__) => { /* eslint-disable node/no-deprecated-api */ @@ -53920,7 +59044,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 50823: +/***/ 17337: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -53949,7 +59073,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /**/ -var Buffer = (__nccwpck_require__(37514).Buffer); +var Buffer = (__nccwpck_require__(35240).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -54223,7 +59347,7 @@ function simpleEnd(buf) { /***/ }), -/***/ 71160: +/***/ 17813: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -54233,7 +59357,7 @@ function simpleEnd(buf) { * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE} * @copyright (c) 2012-2014 Chris Talkington, contributors. */ -var Archiver = __nccwpck_require__(90936); +var Archiver = __nccwpck_require__(35766); var formats = {}; @@ -54305,15 +59429,15 @@ vending.isRegisteredFormat = function (format) { return false; }; -vending.registerFormat('zip', __nccwpck_require__(36926)); -vending.registerFormat('tar', __nccwpck_require__(4134)); -vending.registerFormat('json', __nccwpck_require__(86239)); +vending.registerFormat('zip', __nccwpck_require__(15628)); +vending.registerFormat('tar', __nccwpck_require__(25808)); +vending.registerFormat('json', __nccwpck_require__(28910)); module.exports = vending; /***/ }), -/***/ 90936: +/***/ 35766: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -54324,14 +59448,14 @@ module.exports = vending; * @copyright (c) 2012-2014 Chris Talkington, contributors. */ var fs = __nccwpck_require__(57147); -var glob = __nccwpck_require__(84797); -var async = __nccwpck_require__(81073); +var glob = __nccwpck_require__(49833); +var async = __nccwpck_require__(82831); var path = __nccwpck_require__(71017); -var util = __nccwpck_require__(9925); +var util = __nccwpck_require__(80017); var inherits = (__nccwpck_require__(73837).inherits); -var ArchiverError = __nccwpck_require__(18976); -var Transform = (__nccwpck_require__(84123).Transform); +var ArchiverError = __nccwpck_require__(59066); +var Transform = (__nccwpck_require__(96788).Transform); var win32 = process.platform === 'win32'; @@ -55294,7 +60418,7 @@ module.exports = Archiver; /***/ }), -/***/ 18976: +/***/ 59066: /***/ ((module, exports, __nccwpck_require__) => { /** @@ -55340,7 +60464,7 @@ exports = module.exports = ArchiverError; /***/ }), -/***/ 86239: +/***/ 28910: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -55351,10 +60475,10 @@ exports = module.exports = ArchiverError; * @copyright (c) 2012-2014 Chris Talkington, contributors. */ var inherits = (__nccwpck_require__(73837).inherits); -var Transform = (__nccwpck_require__(84123).Transform); +var Transform = (__nccwpck_require__(96788).Transform); -var crc32 = __nccwpck_require__(6075); -var util = __nccwpck_require__(9925); +var crc32 = __nccwpck_require__(64167); +var util = __nccwpck_require__(80017); /** * @constructor @@ -55457,7 +60581,7 @@ module.exports = Json; /***/ }), -/***/ 4134: +/***/ 25808: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -55469,8 +60593,8 @@ module.exports = Json; */ var zlib = __nccwpck_require__(59796); -var engine = __nccwpck_require__(69658); -var util = __nccwpck_require__(9925); +var engine = __nccwpck_require__(45776); +var util = __nccwpck_require__(80017); /** * @constructor @@ -55631,7 +60755,7 @@ module.exports = Tar; /***/ }), -/***/ 36926: +/***/ 15628: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -55641,8 +60765,8 @@ module.exports = Tar; * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE} * @copyright (c) 2012-2014 Chris Talkington, contributors. */ -var engine = __nccwpck_require__(79293); -var util = __nccwpck_require__(9925); +var engine = __nccwpck_require__(53712); +var util = __nccwpck_require__(80017); /** * @constructor @@ -55758,7 +60882,7 @@ module.exports = Zip; /***/ }), -/***/ 81073: +/***/ 82831: /***/ (function(__unused_webpack_module, exports) { (function (global, factory) { @@ -61823,20 +66947,20 @@ module.exports = Zip; /***/ }), -/***/ 32944: +/***/ 13424: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = { - parallel : __nccwpck_require__(79347), - serial : __nccwpck_require__(99784), - serialOrdered : __nccwpck_require__(98758) + parallel : __nccwpck_require__(17572), + serial : __nccwpck_require__(41342), + serialOrdered : __nccwpck_require__(170) }; /***/ }), -/***/ 56163: +/***/ 30526: /***/ ((module) => { // API @@ -61872,10 +66996,10 @@ function clean(key) /***/ }), -/***/ 61741: +/***/ 11842: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var defer = __nccwpck_require__(91288); +var defer = __nccwpck_require__(61323); // API module.exports = async; @@ -61913,7 +67037,7 @@ function async(callback) /***/ }), -/***/ 91288: +/***/ 61323: /***/ ((module) => { module.exports = defer; @@ -61946,11 +67070,11 @@ function defer(fn) /***/ }), -/***/ 20966: +/***/ 87511: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var async = __nccwpck_require__(61741) - , abort = __nccwpck_require__(56163) +var async = __nccwpck_require__(11842) + , abort = __nccwpck_require__(30526) ; // API @@ -62028,7 +67152,7 @@ function runJob(iterator, key, item, callback) /***/ }), -/***/ 24725: +/***/ 87877: /***/ ((module) => { // API @@ -62072,11 +67196,11 @@ function state(list, sortMethod) /***/ }), -/***/ 82067: +/***/ 54981: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var abort = __nccwpck_require__(56163) - , async = __nccwpck_require__(61741) +var abort = __nccwpck_require__(30526) + , async = __nccwpck_require__(11842) ; // API @@ -62108,12 +67232,12 @@ function terminator(callback) /***/ }), -/***/ 79347: +/***/ 17572: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(20966) - , initState = __nccwpck_require__(24725) - , terminator = __nccwpck_require__(82067) +var iterate = __nccwpck_require__(87511) + , initState = __nccwpck_require__(87877) + , terminator = __nccwpck_require__(54981) ; // Public API @@ -62158,10 +67282,10 @@ function parallel(list, iterator, callback) /***/ }), -/***/ 99784: +/***/ 41342: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var serialOrdered = __nccwpck_require__(98758); +var serialOrdered = __nccwpck_require__(170); // Public API module.exports = serial; @@ -62182,12 +67306,12 @@ function serial(list, iterator, callback) /***/ }), -/***/ 98758: +/***/ 170: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(20966) - , initState = __nccwpck_require__(24725) - , terminator = __nccwpck_require__(82067) +var iterate = __nccwpck_require__(87511) + , initState = __nccwpck_require__(87877) + , terminator = __nccwpck_require__(54981) ; // Public API @@ -62264,7 +67388,7 @@ function descending(a, b) /***/ }), -/***/ 89948: +/***/ 88378: /***/ ((module) => { "use strict"; @@ -62334,12 +67458,12 @@ function range(a, b, str) { /***/ }), -/***/ 18079: +/***/ 10974: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var register = __nccwpck_require__(39367); -var addHook = __nccwpck_require__(55711); -var removeHook = __nccwpck_require__(90037); +var register = __nccwpck_require__(43321); +var addHook = __nccwpck_require__(52434); +var removeHook = __nccwpck_require__(90484); // bind with array of arguments: https://stackoverflow.com/a/21792913 var bind = Function.bind; @@ -62402,7 +67526,7 @@ module.exports.Collection = Hook.Collection; /***/ }), -/***/ 55711: +/***/ 52434: /***/ ((module) => { module.exports = addHook; @@ -62455,7 +67579,7 @@ function addHook(state, kind, name, hook) { /***/ }), -/***/ 39367: +/***/ 43321: /***/ ((module) => { module.exports = register; @@ -62489,7 +67613,7 @@ function register(state, name, method, options) { /***/ }), -/***/ 90037: +/***/ 90484: /***/ ((module) => { module.exports = removeHook; @@ -62515,7 +67639,7 @@ function removeHook(state, name, method) { /***/ }), -/***/ 34312: +/***/ 4795: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /* module decorator */ module = __nccwpck_require__.nmd(module); @@ -63976,13 +69100,13 @@ if (typeof define === "function" && define.amd) { /***/ }), -/***/ 59099: +/***/ 21829: /***/ ((module, exports, __nccwpck_require__) => { -var Chainsaw = __nccwpck_require__(9242); +var Chainsaw = __nccwpck_require__(54865); var EventEmitter = (__nccwpck_require__(82361).EventEmitter); -var Buffers = __nccwpck_require__(53913); -var Vars = __nccwpck_require__(25738); +var Buffers = __nccwpck_require__(2440); +var Vars = __nccwpck_require__(36091); var Stream = (__nccwpck_require__(12781).Stream); exports = module.exports = function (bufOrEm, eventName) { @@ -64380,7 +69504,7 @@ function words (decode) { /***/ }), -/***/ 25738: +/***/ 36091: /***/ ((module) => { module.exports = function (store) { @@ -64415,7 +69539,7 @@ module.exports = function (store) { /***/ }), -/***/ 15710: +/***/ 37050: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -64819,15 +69943,15 @@ module.exports = BufferList /***/ }), -/***/ 69056: +/***/ 55101: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const DuplexStream = (__nccwpck_require__(84123).Duplex) -const inherits = __nccwpck_require__(42991) -const BufferList = __nccwpck_require__(15710) +const DuplexStream = (__nccwpck_require__(96788).Duplex) +const inherits = __nccwpck_require__(56779) +const BufferList = __nccwpck_require__(37050) function BufferListStream (callback) { if (!(this instanceof BufferListStream)) { @@ -64911,7 +70035,7 @@ module.exports.BufferList = BufferList /***/ }), -/***/ 67044: +/***/ 2653: /***/ ((module) => { "use strict"; @@ -64940,16 +70064,16 @@ Promise.prototype.any = function () { /***/ }), -/***/ 66812: +/***/ 68692: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; var firstLineError; try {throw new Error(); } catch (e) {firstLineError = e;} -var schedule = __nccwpck_require__(73484); -var Queue = __nccwpck_require__(36872); -var util = __nccwpck_require__(37180); +var schedule = __nccwpck_require__(68460); +var Queue = __nccwpck_require__(62047); +var util = __nccwpck_require__(27287); function Async() { this._customScheduler = false; @@ -65109,7 +70233,7 @@ module.exports.firstLineError = firstLineError; /***/ }), -/***/ 4999: +/***/ 81032: /***/ ((module) => { "use strict"; @@ -65184,7 +70308,7 @@ Promise.bind = function (thisArg, value) { /***/ }), -/***/ 94453: +/***/ 36044: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65196,14 +70320,14 @@ function noConflict() { catch (e) {} return bluebird; } -var bluebird = __nccwpck_require__(73807)(); +var bluebird = __nccwpck_require__(29384)(); bluebird.noConflict = noConflict; module.exports = bluebird; /***/ }), -/***/ 89343: +/***/ 82594: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65216,7 +70340,7 @@ if (cr) { } module.exports = function(Promise) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var canEvaluate = util.canEvaluate; var isIdentifier = util.isIdentifier; @@ -65334,13 +70458,13 @@ Promise.prototype.get = function (propertyName) { /***/ }), -/***/ 27862: +/***/ 29207: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, PromiseArray, apiRejection, debug) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var tryCatch = util.tryCatch; var errorObj = util.errorObj; var async = Promise._async; @@ -65471,14 +70595,14 @@ Promise.prototype._resultCancelled = function() { /***/ }), -/***/ 87855: +/***/ 55884: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(NEXT_FILTER) { -var util = __nccwpck_require__(37180); -var getKeys = (__nccwpck_require__(61713).keys); +var util = __nccwpck_require__(27287); +var getKeys = (__nccwpck_require__(5697).keys); var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -65521,7 +70645,7 @@ return catchFilter; /***/ }), -/***/ 38518: +/***/ 96635: /***/ ((module) => { "use strict"; @@ -65598,7 +70722,7 @@ return Context; /***/ }), -/***/ 30581: +/***/ 2614: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -65606,8 +70730,8 @@ return Context; module.exports = function(Promise, Context) { var getDomain = Promise._getDomain; var async = Promise._async; -var Warning = (__nccwpck_require__(44581).Warning); -var util = __nccwpck_require__(37180); +var Warning = (__nccwpck_require__(12042).Warning); +var util = __nccwpck_require__(27287); var canAttachTrace = util.canAttachTrace; var unhandledRejectionHandled; var possiblyUnhandledRejection; @@ -66522,7 +71646,7 @@ return { /***/ }), -/***/ 36037: +/***/ 92241: /***/ ((module) => { "use strict"; @@ -66576,7 +71700,7 @@ Promise.prototype.catchReturn = function (value) { /***/ }), -/***/ 56189: +/***/ 35840: /***/ ((module) => { "use strict"; @@ -66614,14 +71738,14 @@ Promise.mapSeries = PromiseMapSeries; /***/ }), -/***/ 44581: +/***/ 12042: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var es5 = __nccwpck_require__(61713); +var es5 = __nccwpck_require__(5697); var Objectfreeze = es5.freeze; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var inherits = util.inherits; var notEnumerableProp = util.notEnumerableProp; @@ -66738,7 +71862,7 @@ module.exports = { /***/ }), -/***/ 61713: +/***/ 5697: /***/ ((module) => { var isES5 = (function(){ @@ -66825,7 +71949,7 @@ if (isES5) { /***/ }), -/***/ 87096: +/***/ 53022: /***/ ((module) => { "use strict"; @@ -66845,13 +71969,13 @@ Promise.filter = function (promises, fn, options) { /***/ }), -/***/ 75523: +/***/ 70625: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, tryConvertToPromise) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var CancellationError = Promise.CancellationError; var errorObj = util.errorObj; @@ -66964,7 +72088,7 @@ return PassThroughHandlerContext; /***/ }), -/***/ 85241: +/***/ 66597: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -66975,9 +72099,9 @@ module.exports = function(Promise, tryConvertToPromise, Proxyable, debug) { -var errors = __nccwpck_require__(44581); +var errors = __nccwpck_require__(12042); var TypeError = errors.TypeError; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var errorObj = util.errorObj; var tryCatch = util.tryCatch; var yieldHandlers = []; @@ -67195,7 +72319,7 @@ Promise.spawn = function (generatorFunction) { /***/ }), -/***/ 28578: +/***/ 19817: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -67203,7 +72327,7 @@ Promise.spawn = function (generatorFunction) { module.exports = function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var canEvaluate = util.canEvaluate; var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -67371,7 +72495,7 @@ Promise.join = function () { /***/ }), -/***/ 64652: +/***/ 36305: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -67383,7 +72507,7 @@ module.exports = function(Promise, INTERNAL, debug) { var getDomain = Promise._getDomain; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var tryCatch = util.tryCatch; var errorObj = util.errorObj; var async = Promise._async; @@ -67547,14 +72671,14 @@ Promise.map = function (promises, fn, options, _filter) { /***/ }), -/***/ 44503: +/***/ 77165: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var tryCatch = util.tryCatch; Promise.method = function (fn) { @@ -67610,16 +72734,16 @@ Promise.prototype._resolveFromSyncValue = function (value) { /***/ }), -/***/ 80683: +/***/ 87824: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var maybeWrapAsError = util.maybeWrapAsError; -var errors = __nccwpck_require__(44581); +var errors = __nccwpck_require__(12042); var OperationalError = errors.OperationalError; -var es5 = __nccwpck_require__(61713); +var es5 = __nccwpck_require__(5697); function isUntypedError(obj) { return obj instanceof Error && @@ -67669,13 +72793,13 @@ module.exports = nodebackForPromise; /***/ }), -/***/ 2576: +/***/ 50784: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var async = Promise._async; var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -67735,7 +72859,7 @@ Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback, /***/ }), -/***/ 73807: +/***/ 29384: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -67752,7 +72876,7 @@ var apiRejection = function(msg) { }; function Proxyable() {} var UNDEFINED_BINDING = {}; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var getDomain; if (util.isNode) { @@ -67768,11 +72892,11 @@ if (util.isNode) { } util.notEnumerableProp(Promise, "_getDomain", getDomain); -var es5 = __nccwpck_require__(61713); -var Async = __nccwpck_require__(66812); +var es5 = __nccwpck_require__(5697); +var Async = __nccwpck_require__(68692); var async = new Async(); es5.defineProperty(Promise, "_async", {value: async}); -var errors = __nccwpck_require__(44581); +var errors = __nccwpck_require__(12042); var TypeError = Promise.TypeError = errors.TypeError; Promise.RangeError = errors.RangeError; var CancellationError = Promise.CancellationError = errors.CancellationError; @@ -67783,19 +72907,19 @@ Promise.AggregateError = errors.AggregateError; var INTERNAL = function(){}; var APPLY = {}; var NEXT_FILTER = {}; -var tryConvertToPromise = __nccwpck_require__(19400)(Promise, INTERNAL); +var tryConvertToPromise = __nccwpck_require__(7038)(Promise, INTERNAL); var PromiseArray = - __nccwpck_require__(86843)(Promise, INTERNAL, + __nccwpck_require__(87197)(Promise, INTERNAL, tryConvertToPromise, apiRejection, Proxyable); -var Context = __nccwpck_require__(38518)(Promise); +var Context = __nccwpck_require__(96635)(Promise); /*jshint unused:false*/ var createContext = Context.create; -var debug = __nccwpck_require__(30581)(Promise, Context); +var debug = __nccwpck_require__(2614)(Promise, Context); var CapturedTrace = debug.CapturedTrace; var PassThroughHandlerContext = - __nccwpck_require__(75523)(Promise, tryConvertToPromise); -var catchFilter = __nccwpck_require__(87855)(NEXT_FILTER); -var nodebackForPromise = __nccwpck_require__(80683); + __nccwpck_require__(70625)(Promise, tryConvertToPromise); +var catchFilter = __nccwpck_require__(55884)(NEXT_FILTER); +var nodebackForPromise = __nccwpck_require__(87824); var errorObj = util.errorObj; var tryCatch = util.tryCatch; function check(self, executor) { @@ -68463,31 +73587,31 @@ util.notEnumerableProp(Promise, "_makeSelfResolutionError", makeSelfResolutionError); -__nccwpck_require__(44503)(Promise, INTERNAL, tryConvertToPromise, apiRejection, +__nccwpck_require__(77165)(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug); -__nccwpck_require__(4999)(Promise, INTERNAL, tryConvertToPromise, debug); -__nccwpck_require__(27862)(Promise, PromiseArray, apiRejection, debug); -__nccwpck_require__(36037)(Promise); -__nccwpck_require__(35506)(Promise); -__nccwpck_require__(28578)( +__nccwpck_require__(81032)(Promise, INTERNAL, tryConvertToPromise, debug); +__nccwpck_require__(29207)(Promise, PromiseArray, apiRejection, debug); +__nccwpck_require__(92241)(Promise); +__nccwpck_require__(23161)(Promise); +__nccwpck_require__(19817)( Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain); Promise.Promise = Promise; Promise.version = "3.4.7"; -__nccwpck_require__(64652)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); -__nccwpck_require__(89343)(Promise); -__nccwpck_require__(324)(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); -__nccwpck_require__(31433)(Promise, INTERNAL, debug); -__nccwpck_require__(85241)(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); -__nccwpck_require__(2576)(Promise); -__nccwpck_require__(16290)(Promise, INTERNAL); -__nccwpck_require__(6237)(Promise, PromiseArray, tryConvertToPromise, apiRejection); -__nccwpck_require__(9493)(Promise, INTERNAL, tryConvertToPromise, apiRejection); -__nccwpck_require__(44712)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); -__nccwpck_require__(25625)(Promise, PromiseArray, debug); -__nccwpck_require__(85041)(Promise, PromiseArray, apiRejection); -__nccwpck_require__(87096)(Promise, INTERNAL); -__nccwpck_require__(56189)(Promise, INTERNAL); -__nccwpck_require__(67044)(Promise); +__nccwpck_require__(36305)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); +__nccwpck_require__(82594)(Promise); +__nccwpck_require__(65339)(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); +__nccwpck_require__(50851)(Promise, INTERNAL, debug); +__nccwpck_require__(66597)(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); +__nccwpck_require__(50784)(Promise); +__nccwpck_require__(23288)(Promise, INTERNAL); +__nccwpck_require__(60754)(Promise, PromiseArray, tryConvertToPromise, apiRejection); +__nccwpck_require__(77730)(Promise, INTERNAL, tryConvertToPromise, apiRejection); +__nccwpck_require__(57416)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); +__nccwpck_require__(52533)(Promise, PromiseArray, debug); +__nccwpck_require__(26158)(Promise, PromiseArray, apiRejection); +__nccwpck_require__(53022)(Promise, INTERNAL); +__nccwpck_require__(35840)(Promise, INTERNAL); +__nccwpck_require__(2653)(Promise); util.toFastProperties(Promise); util.toFastProperties(Promise.prototype); @@ -68516,14 +73640,14 @@ __nccwpck_require__(67044)(Promise); /***/ }), -/***/ 86843: +/***/ 87197: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL, tryConvertToPromise, apiRejection, Proxyable) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var isArray = util.isArray; function toResolutionValue(val) { @@ -68708,19 +73832,19 @@ return PromiseArray; /***/ }), -/***/ 16290: +/***/ 23288: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL) { var THIS = {}; -var util = __nccwpck_require__(37180); -var nodebackForPromise = __nccwpck_require__(80683); +var util = __nccwpck_require__(27287); +var nodebackForPromise = __nccwpck_require__(87824); var withAppended = util.withAppended; var maybeWrapAsError = util.maybeWrapAsError; var canEvaluate = util.canEvaluate; -var TypeError = (__nccwpck_require__(44581).TypeError); +var TypeError = (__nccwpck_require__(12042).TypeError); var defaultSuffix = "Async"; var defaultPromisified = {__isPromisified__: true}; var noCopyProps = [ @@ -69030,16 +74154,16 @@ Promise.promisifyAll = function (target, options) { /***/ }), -/***/ 6237: +/***/ 60754: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function( Promise, PromiseArray, tryConvertToPromise, apiRejection) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var isObject = util.isObject; -var es5 = __nccwpck_require__(61713); +var es5 = __nccwpck_require__(5697); var Es6Map; if (typeof Map === "function") Es6Map = Map; @@ -69156,7 +74280,7 @@ Promise.props = function (promises) { /***/ }), -/***/ 36872: +/***/ 62047: /***/ ((module) => { "use strict"; @@ -69237,14 +74361,14 @@ module.exports = Queue; /***/ }), -/***/ 9493: +/***/ 77730: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function( Promise, INTERNAL, tryConvertToPromise, apiRejection) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var raceLater = function (promise) { return promise.then(function(array) { @@ -69294,7 +74418,7 @@ Promise.prototype.race = function () { /***/ }), -/***/ 44712: +/***/ 57416: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -69306,7 +74430,7 @@ module.exports = function(Promise, INTERNAL, debug) { var getDomain = Promise._getDomain; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var tryCatch = util.tryCatch; function ReductionPromiseArray(promises, fn, initialValue, _each) { @@ -69474,12 +74598,12 @@ function gotValue(value) { /***/ }), -/***/ 73484: +/***/ 68460: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var schedule; var noAsyncScheduler = function() { throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a"); @@ -69543,7 +74667,7 @@ module.exports = schedule; /***/ }), -/***/ 25625: +/***/ 52533: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -69551,7 +74675,7 @@ module.exports = schedule; module.exports = function(Promise, PromiseArray, debug) { var PromiseInspection = Promise.PromiseInspection; -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); function SettledPromiseArray(values) { this.constructor$(values); @@ -69594,16 +74718,16 @@ Promise.prototype.settle = function () { /***/ }), -/***/ 85041: +/***/ 26158: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, PromiseArray, apiRejection) { -var util = __nccwpck_require__(37180); -var RangeError = (__nccwpck_require__(44581).RangeError); -var AggregateError = (__nccwpck_require__(44581).AggregateError); +var util = __nccwpck_require__(27287); +var RangeError = (__nccwpck_require__(12042).RangeError); +var AggregateError = (__nccwpck_require__(12042).AggregateError); var isArray = util.isArray; var CANCELLATION = {}; @@ -69750,7 +74874,7 @@ Promise._SomePromiseArray = SomePromiseArray; /***/ }), -/***/ 35506: +/***/ 23161: /***/ ((module) => { "use strict"; @@ -69861,13 +74985,13 @@ Promise.PromiseInspection = PromiseInspection; /***/ }), -/***/ 19400: +/***/ 7038: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var errorObj = util.errorObj; var isObject = util.isObject; @@ -69955,13 +75079,13 @@ return tryConvertToPromise; /***/ }), -/***/ 31433: +/***/ 50851: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL, debug) { -var util = __nccwpck_require__(37180); +var util = __nccwpck_require__(27287); var TimeoutError = Promise.TimeoutError; function HandleWrapper(handle) { @@ -70056,16 +75180,16 @@ Promise.prototype.timeout = function (ms, message) { /***/ }), -/***/ 324: +/***/ 65339: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function (Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug) { - var util = __nccwpck_require__(37180); - var TypeError = (__nccwpck_require__(44581).TypeError); - var inherits = (__nccwpck_require__(37180).inherits); + var util = __nccwpck_require__(27287); + var TypeError = (__nccwpck_require__(12042).TypeError); + var inherits = (__nccwpck_require__(27287).inherits); var errorObj = util.errorObj; var tryCatch = util.tryCatch; var NULL = {}; @@ -70290,12 +75414,12 @@ module.exports = function (Promise, apiRejection, tryConvertToPromise, /***/ }), -/***/ 37180: +/***/ 27287: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { "use strict"; -var es5 = __nccwpck_require__(61713); +var es5 = __nccwpck_require__(5697); var canEvaluate = typeof navigator == "undefined"; var errorObj = {e: {}}; @@ -70677,7 +75801,7 @@ module.exports = ret; /***/ }), -/***/ 90058: +/***/ 95439: /***/ (function(module) { /** @@ -72207,11 +77331,11 @@ module.exports = ret; /***/ }), -/***/ 84859: +/***/ 82107: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var concatMap = __nccwpck_require__(42360); -var balanced = __nccwpck_require__(89948); +var concatMap = __nccwpck_require__(70434); +var balanced = __nccwpck_require__(88378); module.exports = expandTop; @@ -72415,7 +77539,7 @@ function expand(str, isTop) { /***/ }), -/***/ 6075: +/***/ 64167: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Buffer = (__nccwpck_require__(14300).Buffer); @@ -72533,12 +77657,12 @@ module.exports = crc32; /***/ }), -/***/ 91361: +/***/ 35843: /***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var initBuffer = __nccwpck_require__(9405); +var initBuffer = __nccwpck_require__(75814); if (!Buffer.prototype.indexOf) { Buffer.prototype.indexOf = function (value, offset) { @@ -72614,7 +77738,7 @@ if (Buffer.prototype.lastIndexOf) { /***/ }), -/***/ 9405: +/***/ 75814: /***/ ((module) => { module.exports = function initBuffer(val) { @@ -72628,7 +77752,7 @@ module.exports = function initBuffer(val) { /***/ }), -/***/ 53913: +/***/ 2440: /***/ ((module) => { module.exports = Buffers; @@ -72904,10 +78028,10 @@ Buffers.prototype.toString = function(encoding, start, end) { /***/ }), -/***/ 9242: +/***/ 54865: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var Traverse = __nccwpck_require__(24203); +var Traverse = __nccwpck_require__(79244); var EventEmitter = (__nccwpck_require__(82361).EventEmitter); module.exports = Chainsaw; @@ -73056,12 +78180,12 @@ function upgradeChainsaw(saw) { /***/ }), -/***/ 96283: +/***/ 20130: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(73837); var Stream = (__nccwpck_require__(12781).Stream); -var DelayedStream = __nccwpck_require__(88420); +var DelayedStream = __nccwpck_require__(57538); module.exports = CombinedStream; function CombinedStream() { @@ -73271,7 +78395,7 @@ CombinedStream.prototype._emitError = function(err) { /***/ }), -/***/ 89766: +/***/ 42365: /***/ ((module) => { /** @@ -73293,7 +78417,7 @@ ArchiveEntry.prototype.isDirectory = function() {}; /***/ }), -/***/ 98985: +/***/ 33403: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -73304,10 +78428,10 @@ ArchiveEntry.prototype.isDirectory = function() {}; * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ var inherits = (__nccwpck_require__(73837).inherits); -var Transform = (__nccwpck_require__(84123).Transform); +var Transform = (__nccwpck_require__(96788).Transform); -var ArchiveEntry = __nccwpck_require__(89766); -var util = __nccwpck_require__(67592); +var ArchiveEntry = __nccwpck_require__(42365); +var util = __nccwpck_require__(51605); var ArchiveOutputStream = module.exports = function(options) { if (!(this instanceof ArchiveOutputStream)) { @@ -73416,7 +78540,7 @@ ArchiveOutputStream.prototype.write = function(chunk, cb) { /***/ }), -/***/ 90114: +/***/ 76368: /***/ ((module) => { /** @@ -73494,7 +78618,7 @@ module.exports = { /***/ }), -/***/ 84611: +/***/ 35588: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -73504,7 +78628,7 @@ module.exports = { * Licensed under the MIT license. * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ -var zipUtil = __nccwpck_require__(19195); +var zipUtil = __nccwpck_require__(4001); var DATA_DESCRIPTOR_FLAG = 1 << 3; var ENCRYPTION_FLAG = 1 << 0; @@ -73601,7 +78725,7 @@ GeneralPurposeBit.prototype.usesUTF8ForNames = function() { /***/ }), -/***/ 25743: +/***/ 67420: /***/ ((module) => { /** @@ -73660,7 +78784,7 @@ module.exports = { /***/ }), -/***/ 19195: +/***/ 4001: /***/ ((module) => { /** @@ -73740,7 +78864,7 @@ util.toDosTime = function(d) { /***/ }), -/***/ 54970: +/***/ 99391: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -73751,14 +78875,14 @@ util.toDosTime = function(d) { * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ var inherits = (__nccwpck_require__(73837).inherits); -var normalizePath = __nccwpck_require__(19796); +var normalizePath = __nccwpck_require__(38735); -var ArchiveEntry = __nccwpck_require__(89766); -var GeneralPurposeBit = __nccwpck_require__(84611); -var UnixStat = __nccwpck_require__(25743); +var ArchiveEntry = __nccwpck_require__(42365); +var GeneralPurposeBit = __nccwpck_require__(35588); +var UnixStat = __nccwpck_require__(67420); -var constants = __nccwpck_require__(90114); -var zipUtil = __nccwpck_require__(19195); +var constants = __nccwpck_require__(76368); +var zipUtil = __nccwpck_require__(4001); var ZipArchiveEntry = module.exports = function(name) { if (!(this instanceof ZipArchiveEntry)) { @@ -74160,7 +79284,7 @@ ZipArchiveEntry.prototype.isZip64 = function() { /***/ }), -/***/ 55116: +/***/ 38029: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -74171,17 +79295,17 @@ ZipArchiveEntry.prototype.isZip64 = function() { * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ var inherits = (__nccwpck_require__(73837).inherits); -var crc32 = __nccwpck_require__(6075); -var {CRC32Stream} = __nccwpck_require__(31593); -var {DeflateCRC32Stream} = __nccwpck_require__(31593); +var crc32 = __nccwpck_require__(64167); +var {CRC32Stream} = __nccwpck_require__(41018); +var {DeflateCRC32Stream} = __nccwpck_require__(41018); -var ArchiveOutputStream = __nccwpck_require__(98985); -var ZipArchiveEntry = __nccwpck_require__(54970); -var GeneralPurposeBit = __nccwpck_require__(84611); +var ArchiveOutputStream = __nccwpck_require__(33403); +var ZipArchiveEntry = __nccwpck_require__(99391); +var GeneralPurposeBit = __nccwpck_require__(35588); -var constants = __nccwpck_require__(90114); -var util = __nccwpck_require__(67592); -var zipUtil = __nccwpck_require__(19195); +var constants = __nccwpck_require__(76368); +var util = __nccwpck_require__(51605); +var zipUtil = __nccwpck_require__(4001); var ZipArchiveOutputStream = module.exports = function(options) { if (!(this instanceof ZipArchiveOutputStream)) { @@ -74607,7 +79731,7 @@ ZipArchiveOutputStream.prototype.setComment = function(comment) { /***/ }), -/***/ 21563: +/***/ 28661: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -74618,15 +79742,15 @@ ZipArchiveOutputStream.prototype.setComment = function(comment) { * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ module.exports = { - ArchiveEntry: __nccwpck_require__(89766), - ZipArchiveEntry: __nccwpck_require__(54970), - ArchiveOutputStream: __nccwpck_require__(98985), - ZipArchiveOutputStream: __nccwpck_require__(55116) + ArchiveEntry: __nccwpck_require__(42365), + ZipArchiveEntry: __nccwpck_require__(99391), + ArchiveOutputStream: __nccwpck_require__(33403), + ZipArchiveOutputStream: __nccwpck_require__(38029) }; /***/ }), -/***/ 67592: +/***/ 51605: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -74637,7 +79761,7 @@ module.exports = { * https://github.com/archiverjs/node-compress-commons/blob/master/LICENSE-MIT */ var Stream = (__nccwpck_require__(12781).Stream); -var PassThrough = (__nccwpck_require__(84123).PassThrough); +var PassThrough = (__nccwpck_require__(96788).PassThrough); var util = module.exports = {}; @@ -74662,7 +79786,7 @@ util.normalizeInputSource = function(source) { /***/ }), -/***/ 42360: +/***/ 70434: /***/ ((module) => { module.exports = function (xs, fn) { @@ -74682,7 +79806,7 @@ var isArray = Array.isArray || function (xs) { /***/ }), -/***/ 32137: +/***/ 64601: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { // Copyright Joyent, Inc. and other Node contributors. @@ -74796,7 +79920,7 @@ function objectToString(o) { /***/ }), -/***/ 13080: +/***/ 3458: /***/ ((__unused_webpack_module, exports) => { /*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */ @@ -74910,7 +80034,7 @@ CRC32.str = crc32_str; /***/ }), -/***/ 81629: +/***/ 82468: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -74924,9 +80048,9 @@ CRC32.str = crc32_str; -const {Transform} = __nccwpck_require__(84123); +const {Transform} = __nccwpck_require__(96788); -const crc32 = __nccwpck_require__(13080); +const crc32 = __nccwpck_require__(3458); class CRC32Stream extends Transform { constructor(options) { @@ -74966,7 +80090,7 @@ module.exports = CRC32Stream; /***/ }), -/***/ 32737: +/***/ 42001: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -74982,7 +80106,7 @@ module.exports = CRC32Stream; const {DeflateRaw} = __nccwpck_require__(59796); -const crc32 = __nccwpck_require__(13080); +const crc32 = __nccwpck_require__(3458); class DeflateCRC32Stream extends DeflateRaw { constructor(options) { @@ -75036,7 +80160,7 @@ module.exports = DeflateCRC32Stream; /***/ }), -/***/ 31593: +/***/ 41018: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -75051,14 +80175,14 @@ module.exports = DeflateCRC32Stream; module.exports = { - CRC32Stream: __nccwpck_require__(81629), - DeflateCRC32Stream: __nccwpck_require__(32737) + CRC32Stream: __nccwpck_require__(82468), + DeflateCRC32Stream: __nccwpck_require__(42001) } /***/ }), -/***/ 88420: +/***/ 57538: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = (__nccwpck_require__(12781).Stream); @@ -75172,7 +80296,7 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() { /***/ }), -/***/ 24107: +/***/ 26590: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -75200,7 +80324,7 @@ exports.Deprecation = Deprecation; /***/ }), -/***/ 91205: +/***/ 46037: /***/ ((module) => { "use strict"; @@ -75793,13 +80917,13 @@ module.exports = DotObject /***/ }), -/***/ 90679: +/***/ 86189: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var stream = __nccwpck_require__(53820); +var stream = __nccwpck_require__(43271); function DuplexWrapper(options, writable, readable) { if (typeof readable === "undefined") { @@ -75877,7 +81001,7 @@ module.exports.DuplexWrapper = DuplexWrapper; /***/ }), -/***/ 25293: +/***/ 14279: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -75911,7 +81035,7 @@ module.exports.DuplexWrapper = DuplexWrapper; /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ /**/ @@ -75926,12 +81050,12 @@ var objectKeys = Object.keys || function (obj) { module.exports = Duplex; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ -var Readable = __nccwpck_require__(99148); -var Writable = __nccwpck_require__(41631); +var Readable = __nccwpck_require__(86957); +var Writable = __nccwpck_require__(14821); util.inherits(Duplex, Readable); @@ -76015,7 +81139,7 @@ Duplex.prototype._destroy = function (err, cb) { /***/ }), -/***/ 91182: +/***/ 42159: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -76048,11 +81172,11 @@ Duplex.prototype._destroy = function (err, cb) { module.exports = PassThrough; -var Transform = __nccwpck_require__(90223); +var Transform = __nccwpck_require__(6056); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(PassThrough, Transform); @@ -76069,7 +81193,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 99148: +/***/ 86957: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -76098,13 +81222,13 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Readable; /**/ -var isArray = __nccwpck_require__(80456); +var isArray = __nccwpck_require__(77751); /**/ /**/ @@ -76122,12 +81246,12 @@ var EElistenerCount = function (emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(72740); +var Stream = __nccwpck_require__(1888); /**/ /**/ -var Buffer = (__nccwpck_require__(25003).Buffer); +var Buffer = (__nccwpck_require__(78253).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -76139,8 +81263,8 @@ function _isUint8Array(obj) { /**/ /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ @@ -76153,8 +81277,8 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(2217); -var destroyImpl = __nccwpck_require__(97098); +var BufferList = __nccwpck_require__(93932); +var destroyImpl = __nccwpck_require__(27003); var StringDecoder; util.inherits(Readable, Stream); @@ -76174,7 +81298,7 @@ function prependListener(emitter, event, fn) { } function ReadableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(25293); + Duplex = Duplex || __nccwpck_require__(14279); options = options || {}; @@ -76244,14 +81368,14 @@ function ReadableState(options, stream) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(49807)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(76931)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(25293); + Duplex = Duplex || __nccwpck_require__(14279); if (!(this instanceof Readable)) return new Readable(options); @@ -76400,7 +81524,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(49807)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(76931)/* .StringDecoder */ .s); this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; @@ -77095,7 +82219,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 90223: +/***/ 6056: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -77166,11 +82290,11 @@ function indexOf(xs, x) { module.exports = Transform; -var Duplex = __nccwpck_require__(25293); +var Duplex = __nccwpck_require__(14279); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(Transform, Duplex); @@ -77316,7 +82440,7 @@ function done(stream, er, data) { /***/ }), -/***/ 41631: +/***/ 14821: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -77349,7 +82473,7 @@ function done(stream, er, data) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Writable; @@ -77386,23 +82510,23 @@ var Duplex; Writable.WritableState = WritableState; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ var internalUtil = { - deprecate: __nccwpck_require__(98485) + deprecate: __nccwpck_require__(20524) }; /**/ /**/ -var Stream = __nccwpck_require__(72740); +var Stream = __nccwpck_require__(1888); /**/ /**/ -var Buffer = (__nccwpck_require__(25003).Buffer); +var Buffer = (__nccwpck_require__(78253).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -77413,14 +82537,14 @@ function _isUint8Array(obj) { /**/ -var destroyImpl = __nccwpck_require__(97098); +var destroyImpl = __nccwpck_require__(27003); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(25293); + Duplex = Duplex || __nccwpck_require__(14279); options = options || {}; @@ -77570,7 +82694,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(25293); + Duplex = Duplex || __nccwpck_require__(14279); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -78008,7 +83132,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 2217: +/***/ 93932: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -78016,7 +83140,7 @@ Writable.prototype._destroy = function (err, cb) { function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var Buffer = (__nccwpck_require__(25003).Buffer); +var Buffer = (__nccwpck_require__(78253).Buffer); var util = __nccwpck_require__(73837); function copyBuffer(src, target, offset) { @@ -78093,7 +83217,7 @@ if (util && util.inspect && util.inspect.custom) { /***/ }), -/***/ 97098: +/***/ 27003: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -78101,7 +83225,7 @@ if (util && util.inspect && util.inspect.custom) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ // undocumented cb() API, needed for core, not for public API @@ -78184,7 +83308,7 @@ module.exports = { /***/ }), -/***/ 72740: +/***/ 1888: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -78192,7 +83316,7 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 53820: +/***/ 43271: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -78206,19 +83330,19 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { exports.PassThrough = Stream.PassThrough; exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(99148); + exports = module.exports = __nccwpck_require__(86957); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(41631); - exports.Duplex = __nccwpck_require__(25293); - exports.Transform = __nccwpck_require__(90223); - exports.PassThrough = __nccwpck_require__(91182); + exports.Writable = __nccwpck_require__(14821); + exports.Duplex = __nccwpck_require__(14279); + exports.Transform = __nccwpck_require__(6056); + exports.PassThrough = __nccwpck_require__(42159); } /***/ }), -/***/ 25003: +/***/ 78253: /***/ ((module, exports, __nccwpck_require__) => { /* eslint-disable node/no-deprecated-api */ @@ -78287,7 +83411,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 49807: +/***/ 76931: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -78316,7 +83440,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /**/ -var Buffer = (__nccwpck_require__(25003).Buffer); +var Buffer = (__nccwpck_require__(78253).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -78590,10 +83714,10 @@ function simpleEnd(buf) { /***/ }), -/***/ 95688: +/***/ 60522: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var once = __nccwpck_require__(58203); +var once = __nccwpck_require__(55493); var noop = function() {}; @@ -78691,10 +83815,10 @@ module.exports = eos; /***/ }), -/***/ 79700: +/***/ 44374: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var CombinedStream = __nccwpck_require__(96283); +var CombinedStream = __nccwpck_require__(20130); var util = __nccwpck_require__(73837); var path = __nccwpck_require__(71017); var http = __nccwpck_require__(13685); @@ -78702,9 +83826,9 @@ var https = __nccwpck_require__(95687); var parseUrl = (__nccwpck_require__(57310).parse); var fs = __nccwpck_require__(57147); var Stream = (__nccwpck_require__(12781).Stream); -var mime = __nccwpck_require__(76628); -var asynckit = __nccwpck_require__(32944); -var populate = __nccwpck_require__(8065); +var mime = __nccwpck_require__(83357); +var asynckit = __nccwpck_require__(13424); +var populate = __nccwpck_require__(63498); // Public API module.exports = FormData; @@ -79199,7 +84323,7 @@ FormData.prototype.toString = function () { /***/ }), -/***/ 8065: +/***/ 63498: /***/ ((module) => { // populates missing values @@ -79216,7 +84340,7 @@ module.exports = function(dst, src) { /***/ }), -/***/ 53370: +/***/ 41475: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = (__nccwpck_require__(57147).constants) || __nccwpck_require__(22057) @@ -79224,7 +84348,7 @@ module.exports = (__nccwpck_require__(57147).constants) || __nccwpck_require__(2 /***/ }), -/***/ 54421: +/***/ 61883: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = realpath @@ -79240,7 +84364,7 @@ var origRealpathSync = fs.realpathSync var version = process.version var ok = /^v[0-5]\./.test(version) -var old = __nccwpck_require__(85877) +var old = __nccwpck_require__(92859) function newError (er) { return er && er.syscall === 'realpath' && ( @@ -79297,7 +84421,7 @@ function unmonkeypatch () { /***/ }), -/***/ 85877: +/***/ 92859: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { // Copyright Joyent, Inc. and other Node contributors. @@ -79607,32 +84731,32 @@ exports.realpath = function realpath(p, cache, cb) { /***/ }), -/***/ 45694: +/***/ 31382: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { var __webpack_unused_export__; -/* unused reexport */ __nccwpck_require__(32705) -/* unused reexport */ __nccwpck_require__(54707) -exports.Writer = __nccwpck_require__(36210) +/* unused reexport */ __nccwpck_require__(10567) +/* unused reexport */ __nccwpck_require__(1478) +exports.Writer = __nccwpck_require__(2318) exports.$B = { - Reader: __nccwpck_require__(33238), - Writer: __nccwpck_require__(23604) + Reader: __nccwpck_require__(92832), + Writer: __nccwpck_require__(96691) } exports.Lv = { - Reader: __nccwpck_require__(55069), - Writer: __nccwpck_require__(39359) + Reader: __nccwpck_require__(22516), + Writer: __nccwpck_require__(52336) } exports.rU = { - Reader: __nccwpck_require__(52919), - Writer: __nccwpck_require__(97876) + Reader: __nccwpck_require__(44449), + Writer: __nccwpck_require__(60022) } exports._S = { - Reader: __nccwpck_require__(40233), - Writer: __nccwpck_require__(29485) + Reader: __nccwpck_require__(17689), + Writer: __nccwpck_require__(34064) } __webpack_unused_export__ = __webpack_unused_export__ = exports.Lv.Reader @@ -79645,12 +84769,12 @@ exports.Writer.File = __webpack_unused_export__ = exports.$B.Writer exports.Writer.Link = __webpack_unused_export__ = exports.rU.Writer exports.Writer.Proxy = __webpack_unused_export__ = exports._S.Writer -/* unused reexport */ __nccwpck_require__(48324) +/* unused reexport */ __nccwpck_require__(45629) /***/ }), -/***/ 32705: +/***/ 10567: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // the parent class for all fstreams. @@ -79658,7 +84782,7 @@ exports.Writer.Proxy = __webpack_unused_export__ = exports._S.Writer module.exports = Abstract var Stream = (__nccwpck_require__(12781).Stream) -var inherits = __nccwpck_require__(42991) +var inherits = __nccwpck_require__(56779) function Abstract () { Stream.call(this) @@ -79742,7 +84866,7 @@ function decorate (er, code, self) { /***/ }), -/***/ 48324: +/***/ 45629: /***/ ((module) => { module.exports = collect @@ -79819,7 +84943,7 @@ function collect (stream) { /***/ }), -/***/ 55069: +/***/ 22516: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // A thing that emits "entry" events with Reader objects @@ -79828,10 +84952,10 @@ function collect (stream) { module.exports = DirReader -var fs = __nccwpck_require__(91468) -var inherits = __nccwpck_require__(42991) +var fs = __nccwpck_require__(80759) +var inherits = __nccwpck_require__(56779) var path = __nccwpck_require__(71017) -var Reader = __nccwpck_require__(54707) +var Reader = __nccwpck_require__(1478) var assert = (__nccwpck_require__(39491).ok) inherits(DirReader, Reader) @@ -80078,7 +85202,7 @@ DirReader.prototype.emitEntry = function (entry) { /***/ }), -/***/ 39359: +/***/ 52336: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // It is expected that, when .add() returns false, the consumer @@ -80089,11 +85213,11 @@ DirReader.prototype.emitEntry = function (entry) { module.exports = DirWriter -var Writer = __nccwpck_require__(36210) -var inherits = __nccwpck_require__(42991) -var mkdir = __nccwpck_require__(19927) +var Writer = __nccwpck_require__(2318) +var inherits = __nccwpck_require__(56779) +var mkdir = __nccwpck_require__(34118) var path = __nccwpck_require__(71017) -var collect = __nccwpck_require__(48324) +var collect = __nccwpck_require__(45629) inherits(DirWriter, Writer) @@ -80259,16 +85383,16 @@ DirWriter.prototype._process = function () { /***/ }), -/***/ 33238: +/***/ 92832: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Basically just a wrapper around an fs.ReadStream module.exports = FileReader -var fs = __nccwpck_require__(91468) -var inherits = __nccwpck_require__(42991) -var Reader = __nccwpck_require__(54707) +var fs = __nccwpck_require__(80759) +var inherits = __nccwpck_require__(56779) +var Reader = __nccwpck_require__(1478) var EOF = {EOF: true} var CLOSE = {CLOSE: true} @@ -80416,14 +85540,14 @@ FileReader.prototype.resume = function (who) { /***/ }), -/***/ 23604: +/***/ 96691: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = FileWriter -var fs = __nccwpck_require__(91468) -var Writer = __nccwpck_require__(36210) -var inherits = __nccwpck_require__(42991) +var fs = __nccwpck_require__(80759) +var Writer = __nccwpck_require__(2318) +var inherits = __nccwpck_require__(56779) var EOF = {} inherits(FileWriter, Writer) @@ -80530,7 +85654,7 @@ FileWriter.prototype._finish = function () { /***/ }), -/***/ 53494: +/***/ 28163: /***/ ((module) => { module.exports = getType @@ -80570,7 +85694,7 @@ function getType (st) { /***/ }), -/***/ 52919: +/***/ 44449: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Basically just a wrapper around an fs.readlink @@ -80581,9 +85705,9 @@ function getType (st) { module.exports = LinkReader -var fs = __nccwpck_require__(91468) -var inherits = __nccwpck_require__(42991) -var Reader = __nccwpck_require__(54707) +var fs = __nccwpck_require__(80759) +var inherits = __nccwpck_require__(56779) +var Reader = __nccwpck_require__(1478) inherits(LinkReader, Reader) @@ -80630,16 +85754,16 @@ LinkReader.prototype._read = function () { /***/ }), -/***/ 97876: +/***/ 60022: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = LinkWriter -var fs = __nccwpck_require__(91468) -var Writer = __nccwpck_require__(36210) -var inherits = __nccwpck_require__(42991) +var fs = __nccwpck_require__(80759) +var Writer = __nccwpck_require__(2318) +var inherits = __nccwpck_require__(56779) var path = __nccwpck_require__(71017) -var rimraf = __nccwpck_require__(9651) +var rimraf = __nccwpck_require__(51133) inherits(LinkWriter, Writer) @@ -80732,7 +85856,7 @@ LinkWriter.prototype.end = function () { /***/ }), -/***/ 40233: +/***/ 17689: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // A reader for when we don't yet know what kind of thing @@ -80740,10 +85864,10 @@ LinkWriter.prototype.end = function () { module.exports = ProxyReader -var Reader = __nccwpck_require__(54707) -var getType = __nccwpck_require__(53494) -var inherits = __nccwpck_require__(42991) -var fs = __nccwpck_require__(91468) +var Reader = __nccwpck_require__(1478) +var getType = __nccwpck_require__(28163) +var inherits = __nccwpck_require__(56779) +var fs = __nccwpck_require__(80759) inherits(ProxyReader, Reader) @@ -80834,7 +85958,7 @@ ProxyReader.prototype.resume = function () { /***/ }), -/***/ 29485: +/***/ 34064: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // A writer for when we don't know what kind of thing @@ -80846,10 +85970,10 @@ ProxyReader.prototype.resume = function () { module.exports = ProxyWriter -var Writer = __nccwpck_require__(36210) -var getType = __nccwpck_require__(53494) -var inherits = __nccwpck_require__(42991) -var collect = __nccwpck_require__(48324) +var Writer = __nccwpck_require__(2318) +var getType = __nccwpck_require__(28163) +var inherits = __nccwpck_require__(56779) +var collect = __nccwpck_require__(45629) var fs = __nccwpck_require__(57147) inherits(ProxyWriter, Writer) @@ -80952,23 +86076,23 @@ ProxyWriter.prototype.end = function (c) { /***/ }), -/***/ 54707: +/***/ 1478: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = Reader -var fs = __nccwpck_require__(91468) +var fs = __nccwpck_require__(80759) var Stream = (__nccwpck_require__(12781).Stream) -var inherits = __nccwpck_require__(42991) +var inherits = __nccwpck_require__(56779) var path = __nccwpck_require__(71017) -var getType = __nccwpck_require__(53494) +var getType = __nccwpck_require__(28163) var hardLinks = Reader.hardLinks = {} -var Abstract = __nccwpck_require__(32705) +var Abstract = __nccwpck_require__(10567) // Must do this *before* loading the child classes inherits(Reader, Abstract) -var LinkReader = __nccwpck_require__(52919) +var LinkReader = __nccwpck_require__(44449) function Reader (props, currentStat) { var self = this @@ -81003,7 +86127,7 @@ function Reader (props, currentStat) { switch (type) { case 'Directory': - ClassType = __nccwpck_require__(55069) + ClassType = __nccwpck_require__(22516) break case 'Link': @@ -81016,7 +86140,7 @@ function Reader (props, currentStat) { // break case 'File': - ClassType = __nccwpck_require__(33238) + ClassType = __nccwpck_require__(92832) break case 'SymbolicLink': @@ -81024,11 +86148,11 @@ function Reader (props, currentStat) { break case 'Socket': - ClassType = __nccwpck_require__(68557) + ClassType = __nccwpck_require__(51044) break case null: - ClassType = __nccwpck_require__(40233) + ClassType = __nccwpck_require__(17689) break } @@ -81214,7 +86338,7 @@ Reader.prototype._read = function () { /***/ }), -/***/ 68557: +/***/ 51044: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Just get the stats, and then don't do anything. @@ -81224,8 +86348,8 @@ Reader.prototype._read = function () { module.exports = SocketReader -var inherits = __nccwpck_require__(42991) -var Reader = __nccwpck_require__(54707) +var inherits = __nccwpck_require__(56779) +var Reader = __nccwpck_require__(1478) inherits(SocketReader, Reader) @@ -81257,19 +86381,19 @@ SocketReader.prototype._read = function () { /***/ }), -/***/ 36210: +/***/ 2318: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = Writer -var fs = __nccwpck_require__(91468) -var inherits = __nccwpck_require__(42991) -var rimraf = __nccwpck_require__(9651) -var mkdir = __nccwpck_require__(19927) +var fs = __nccwpck_require__(80759) +var inherits = __nccwpck_require__(56779) +var rimraf = __nccwpck_require__(51133) +var mkdir = __nccwpck_require__(34118) var path = __nccwpck_require__(71017) var umask = process.platform === 'win32' ? 0 : process.umask() -var getType = __nccwpck_require__(53494) -var Abstract = __nccwpck_require__(32705) +var getType = __nccwpck_require__(28163) +var Abstract = __nccwpck_require__(10567) // Must do this *before* loading the child classes inherits(Writer, Abstract) @@ -81277,10 +86401,10 @@ inherits(Writer, Abstract) Writer.dirmode = parseInt('0777', 8) & (~umask) Writer.filemode = parseInt('0666', 8) & (~umask) -var DirWriter = __nccwpck_require__(39359) -var LinkWriter = __nccwpck_require__(97876) -var FileWriter = __nccwpck_require__(23604) -var ProxyWriter = __nccwpck_require__(29485) +var DirWriter = __nccwpck_require__(52336) +var LinkWriter = __nccwpck_require__(60022) +var FileWriter = __nccwpck_require__(96691) +var ProxyWriter = __nccwpck_require__(34064) // props is the desired state. current is optionally the current stat, // provided here so that subclasses can avoid statting the target @@ -81654,7 +86778,7 @@ function isDate (d) { /***/ }), -/***/ 38603: +/***/ 91446: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { exports.setopts = setopts @@ -81671,8 +86795,8 @@ function ownProp (obj, field) { var fs = __nccwpck_require__(57147) var path = __nccwpck_require__(71017) -var minimatch = __nccwpck_require__(4989) -var isAbsolute = __nccwpck_require__(72934) +var minimatch = __nccwpck_require__(39034) +var isAbsolute = __nccwpck_require__(23657) var Minimatch = minimatch.Minimatch function alphasort (a, b) { @@ -81899,7 +87023,7 @@ function childrenIgnored (self, path) { /***/ }), -/***/ 3661: +/***/ 19830: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Approach: @@ -81944,24 +87068,24 @@ function childrenIgnored (self, path) { module.exports = glob -var rp = __nccwpck_require__(54421) -var minimatch = __nccwpck_require__(4989) +var rp = __nccwpck_require__(61883) +var minimatch = __nccwpck_require__(39034) var Minimatch = minimatch.Minimatch -var inherits = __nccwpck_require__(42991) +var inherits = __nccwpck_require__(56779) var EE = (__nccwpck_require__(82361).EventEmitter) var path = __nccwpck_require__(71017) var assert = __nccwpck_require__(39491) -var isAbsolute = __nccwpck_require__(72934) -var globSync = __nccwpck_require__(25102) -var common = __nccwpck_require__(38603) +var isAbsolute = __nccwpck_require__(23657) +var globSync = __nccwpck_require__(36155) +var common = __nccwpck_require__(91446) var setopts = common.setopts var ownProp = common.ownProp -var inflight = __nccwpck_require__(77505) +var inflight = __nccwpck_require__(40344) var util = __nccwpck_require__(73837) var childrenIgnored = common.childrenIgnored var isIgnored = common.isIgnored -var once = __nccwpck_require__(58203) +var once = __nccwpck_require__(55493) function glob (pattern, options, cb) { if (typeof options === 'function') cb = options, options = {} @@ -82696,21 +87820,21 @@ Glob.prototype._stat2 = function (f, abs, er, stat, cb) { /***/ }), -/***/ 25102: +/***/ 36155: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = globSync globSync.GlobSync = GlobSync -var rp = __nccwpck_require__(54421) -var minimatch = __nccwpck_require__(4989) +var rp = __nccwpck_require__(61883) +var minimatch = __nccwpck_require__(39034) var Minimatch = minimatch.Minimatch -var Glob = (__nccwpck_require__(3661).Glob) +var Glob = (__nccwpck_require__(19830).Glob) var util = __nccwpck_require__(73837) var path = __nccwpck_require__(71017) var assert = __nccwpck_require__(39491) -var isAbsolute = __nccwpck_require__(72934) -var common = __nccwpck_require__(38603) +var isAbsolute = __nccwpck_require__(23657) +var common = __nccwpck_require__(91446) var setopts = common.setopts var ownProp = common.ownProp var childrenIgnored = common.childrenIgnored @@ -83189,7 +88313,7 @@ GlobSync.prototype._makeAbs = function (f) { /***/ }), -/***/ 38612: +/***/ 99125: /***/ ((module) => { "use strict"; @@ -83220,13 +88344,13 @@ function clone (obj) { /***/ }), -/***/ 91468: +/***/ 80759: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var fs = __nccwpck_require__(57147) -var polyfills = __nccwpck_require__(99283) -var legacy = __nccwpck_require__(74465) -var clone = __nccwpck_require__(38612) +var polyfills = __nccwpck_require__(31489) +var legacy = __nccwpck_require__(1779) +var clone = __nccwpck_require__(99125) var util = __nccwpck_require__(73837) @@ -83675,7 +88799,7 @@ function retry () { /***/ }), -/***/ 74465: +/***/ 1779: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = (__nccwpck_require__(12781).Stream) @@ -83800,7 +88924,7 @@ function legacy (fs) { /***/ }), -/***/ 99283: +/***/ 31489: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var constants = __nccwpck_require__(22057) @@ -84162,12 +89286,12 @@ function patch (fs) { /***/ }), -/***/ 77505: +/***/ 40344: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var wrappy = __nccwpck_require__(39148) +var wrappy = __nccwpck_require__(3634) var reqs = Object.create(null) -var once = __nccwpck_require__(58203) +var once = __nccwpck_require__(55493) module.exports = wrappy(inflight) @@ -84223,7 +89347,7 @@ function slice (args) { /***/ }), -/***/ 42991: +/***/ 56779: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { try { @@ -84233,13 +89357,13 @@ try { module.exports = util.inherits; } catch (e) { /* istanbul ignore next */ - module.exports = __nccwpck_require__(38624); + module.exports = __nccwpck_require__(47808); } /***/ }), -/***/ 38624: +/***/ 47808: /***/ ((module) => { if (typeof Object.create === 'function') { @@ -84273,7 +89397,7 @@ if (typeof Object.create === 'function') { /***/ }), -/***/ 54132: +/***/ 30655: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -84319,7 +89443,7 @@ exports.isPlainObject = isPlainObject; /***/ }), -/***/ 80456: +/***/ 77751: /***/ ((module) => { var toString = {}.toString; @@ -84331,7 +89455,7 @@ module.exports = Array.isArray || function (arr) { /***/ }), -/***/ 25582: +/***/ 49929: /***/ ((module) => { "use strict"; @@ -84341,11 +89465,11 @@ function e(e){this.message=e}e.prototype=new Error,e.prototype.name="InvalidChar /***/ }), -/***/ 9936: +/***/ 14137: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(73837); -var PassThrough = __nccwpck_require__(8873); +var PassThrough = __nccwpck_require__(46090); module.exports = { Readable: Readable, @@ -84402,7 +89526,7 @@ function Writable(fn, options) { /***/ }), -/***/ 28409: +/***/ 81143: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -84436,7 +89560,7 @@ function Writable(fn, options) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ /**/ @@ -84451,12 +89575,12 @@ var objectKeys = Object.keys || function (obj) { module.exports = Duplex; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ -var Readable = __nccwpck_require__(90708); -var Writable = __nccwpck_require__(32383); +var Readable = __nccwpck_require__(33888); +var Writable = __nccwpck_require__(58661); util.inherits(Duplex, Readable); @@ -84540,7 +89664,7 @@ Duplex.prototype._destroy = function (err, cb) { /***/ }), -/***/ 65285: +/***/ 62372: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -84573,11 +89697,11 @@ Duplex.prototype._destroy = function (err, cb) { module.exports = PassThrough; -var Transform = __nccwpck_require__(60927); +var Transform = __nccwpck_require__(73186); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(PassThrough, Transform); @@ -84594,7 +89718,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 90708: +/***/ 33888: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -84623,13 +89747,13 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Readable; /**/ -var isArray = __nccwpck_require__(80456); +var isArray = __nccwpck_require__(77751); /**/ /**/ @@ -84647,12 +89771,12 @@ var EElistenerCount = function (emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(77660); +var Stream = __nccwpck_require__(54216); /**/ /**/ -var Buffer = (__nccwpck_require__(63997).Buffer); +var Buffer = (__nccwpck_require__(18565).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -84664,8 +89788,8 @@ function _isUint8Array(obj) { /**/ /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ @@ -84678,8 +89802,8 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(78490); -var destroyImpl = __nccwpck_require__(11434); +var BufferList = __nccwpck_require__(53784); +var destroyImpl = __nccwpck_require__(37883); var StringDecoder; util.inherits(Readable, Stream); @@ -84699,7 +89823,7 @@ function prependListener(emitter, event, fn) { } function ReadableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(28409); + Duplex = Duplex || __nccwpck_require__(81143); options = options || {}; @@ -84769,14 +89893,14 @@ function ReadableState(options, stream) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(91843)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(74940)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(28409); + Duplex = Duplex || __nccwpck_require__(81143); if (!(this instanceof Readable)) return new Readable(options); @@ -84925,7 +90049,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(91843)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(74940)/* .StringDecoder */ .s); this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; @@ -85620,7 +90744,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 60927: +/***/ 73186: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -85691,11 +90815,11 @@ function indexOf(xs, x) { module.exports = Transform; -var Duplex = __nccwpck_require__(28409); +var Duplex = __nccwpck_require__(81143); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(Transform, Duplex); @@ -85841,7 +90965,7 @@ function done(stream, er, data) { /***/ }), -/***/ 32383: +/***/ 58661: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -85874,7 +90998,7 @@ function done(stream, er, data) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Writable; @@ -85911,23 +91035,23 @@ var Duplex; Writable.WritableState = WritableState; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ var internalUtil = { - deprecate: __nccwpck_require__(98485) + deprecate: __nccwpck_require__(20524) }; /**/ /**/ -var Stream = __nccwpck_require__(77660); +var Stream = __nccwpck_require__(54216); /**/ /**/ -var Buffer = (__nccwpck_require__(63997).Buffer); +var Buffer = (__nccwpck_require__(18565).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -85938,14 +91062,14 @@ function _isUint8Array(obj) { /**/ -var destroyImpl = __nccwpck_require__(11434); +var destroyImpl = __nccwpck_require__(37883); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(28409); + Duplex = Duplex || __nccwpck_require__(81143); options = options || {}; @@ -86095,7 +91219,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(28409); + Duplex = Duplex || __nccwpck_require__(81143); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -86533,7 +91657,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 78490: +/***/ 53784: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -86541,7 +91665,7 @@ Writable.prototype._destroy = function (err, cb) { function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var Buffer = (__nccwpck_require__(63997).Buffer); +var Buffer = (__nccwpck_require__(18565).Buffer); var util = __nccwpck_require__(73837); function copyBuffer(src, target, offset) { @@ -86618,7 +91742,7 @@ if (util && util.inspect && util.inspect.custom) { /***/ }), -/***/ 11434: +/***/ 37883: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -86626,7 +91750,7 @@ if (util && util.inspect && util.inspect.custom) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ // undocumented cb() API, needed for core, not for public API @@ -86709,7 +91833,7 @@ module.exports = { /***/ }), -/***/ 77660: +/***/ 54216: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -86717,15 +91841,15 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 8873: +/***/ 46090: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(86559).PassThrough +module.exports = __nccwpck_require__(24214).PassThrough /***/ }), -/***/ 86559: +/***/ 24214: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -86739,19 +91863,19 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { exports.PassThrough = Stream.PassThrough; exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(90708); + exports = module.exports = __nccwpck_require__(33888); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(32383); - exports.Duplex = __nccwpck_require__(28409); - exports.Transform = __nccwpck_require__(60927); - exports.PassThrough = __nccwpck_require__(65285); + exports.Writable = __nccwpck_require__(58661); + exports.Duplex = __nccwpck_require__(81143); + exports.Transform = __nccwpck_require__(73186); + exports.PassThrough = __nccwpck_require__(62372); } /***/ }), -/***/ 63997: +/***/ 18565: /***/ ((module, exports, __nccwpck_require__) => { /* eslint-disable node/no-deprecated-api */ @@ -86820,7 +91944,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 91843: +/***/ 74940: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -86849,7 +91973,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /**/ -var Buffer = (__nccwpck_require__(63997).Buffer); +var Buffer = (__nccwpck_require__(18565).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -87123,7 +92247,7 @@ function simpleEnd(buf) { /***/ }), -/***/ 70891: +/***/ 51362: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -87147,7 +92271,7 @@ module.exports = listenerCount /***/ }), -/***/ 14285: +/***/ 53703: /***/ ((module) => { /** @@ -87822,7 +92946,7 @@ module.exports = defaults; /***/ }), -/***/ 23651: +/***/ 53229: /***/ ((module) => { /** @@ -88999,7 +94123,7 @@ module.exports = difference; /***/ }), -/***/ 25402: +/***/ 14926: /***/ ((module) => { /** @@ -89355,7 +94479,7 @@ module.exports = flatten; /***/ }), -/***/ 98466: +/***/ 94507: /***/ ((module) => { /** @@ -89501,7 +94625,7 @@ module.exports = isPlainObject; /***/ }), -/***/ 76640: +/***/ 13643: /***/ ((module) => { /** @@ -90689,7 +95813,7 @@ module.exports = union; /***/ }), -/***/ 72457: +/***/ 5302: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /*! @@ -90703,12 +95827,12 @@ module.exports = union; * Module exports. */ -module.exports = __nccwpck_require__(2131) +module.exports = __nccwpck_require__(22913) /***/ }), -/***/ 76628: +/***/ 83357: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -90726,7 +95850,7 @@ module.exports = __nccwpck_require__(2131) * @private */ -var db = __nccwpck_require__(72457) +var db = __nccwpck_require__(5302) var extname = (__nccwpck_require__(71017).extname) /** @@ -90904,7 +96028,7 @@ function populateMaps (extensions, types) { /***/ }), -/***/ 4989: +/***/ 39034: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = minimatch @@ -90916,7 +96040,7 @@ var path = (function () { try { return __nccwpck_require__(71017) } catch (e) {} minimatch.sep = path.sep var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} -var expand = __nccwpck_require__(84859) +var expand = __nccwpck_require__(82107) var plTypes = { '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, @@ -91858,7 +96982,7 @@ function regExpEscape (s) { /***/ }), -/***/ 19927: +/***/ 34118: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var path = __nccwpck_require__(71017); @@ -91967,7 +97091,7 @@ mkdirP.sync = function sync (p, opts, made) { /***/ }), -/***/ 96295: +/***/ 35325: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; @@ -91980,7 +97104,7 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau var Stream = _interopDefault(__nccwpck_require__(12781)); var http = _interopDefault(__nccwpck_require__(13685)); var Url = _interopDefault(__nccwpck_require__(57310)); -var whatwgUrl = _interopDefault(__nccwpck_require__(42801)); +var whatwgUrl = _interopDefault(__nccwpck_require__(18921)); var https = _interopDefault(__nccwpck_require__(95687)); var zlib = _interopDefault(__nccwpck_require__(59796)); @@ -92133,7 +97257,7 @@ FetchError.prototype.name = 'FetchError'; let convert; try { - convert = (__nccwpck_require__(56966)/* .convert */ .O); + convert = (__nccwpck_require__(15633)/* .convert */ .O); } catch (e) {} const INTERNALS = Symbol('Body internals'); @@ -93765,7 +98889,7 @@ exports.FetchError = FetchError; /***/ }), -/***/ 19796: +/***/ 38735: /***/ ((module) => { /*! @@ -93807,10 +98931,10 @@ module.exports = function(path, stripTrailing) { /***/ }), -/***/ 58203: +/***/ 55493: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var wrappy = __nccwpck_require__(39148) +var wrappy = __nccwpck_require__(3634) module.exports = wrappy(once) module.exports.strict = wrappy(onceStrict) @@ -93856,7 +98980,7 @@ function onceStrict (fn) { /***/ }), -/***/ 72934: +/***/ 23657: /***/ ((module) => { "use strict"; @@ -93884,7 +99008,7 @@ module.exports.win32 = win32; /***/ }), -/***/ 13817: +/***/ 26314: /***/ ((module) => { "use strict"; @@ -93937,7 +99061,7 @@ function nextTick(fn, arg1, arg2, arg3) { /***/ }), -/***/ 17778: +/***/ 20458: /***/ ((module) => { "use strict"; @@ -94061,7 +99185,7 @@ module.exports.q = codes; /***/ }), -/***/ 47116: +/***/ 50502: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -94102,9 +99226,9 @@ var objectKeys = Object.keys || function (obj) { /**/ module.exports = Duplex; -var Readable = __nccwpck_require__(43170); -var Writable = __nccwpck_require__(90205); -__nccwpck_require__(42991)(Duplex, Readable); +var Readable = __nccwpck_require__(3220); +var Writable = __nccwpck_require__(49105); +__nccwpck_require__(56779)(Duplex, Readable); { // Allow the keys array to be GC'ed. var keys = objectKeys(Writable.prototype); @@ -94194,7 +99318,7 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { /***/ }), -/***/ 63515: +/***/ 11076: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -94226,8 +99350,8 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { module.exports = PassThrough; -var Transform = __nccwpck_require__(176); -__nccwpck_require__(42991)(PassThrough, Transform); +var Transform = __nccwpck_require__(62065); +__nccwpck_require__(56779)(PassThrough, Transform); function PassThrough(options) { if (!(this instanceof PassThrough)) return new PassThrough(options); Transform.call(this, options); @@ -94238,7 +99362,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 43170: +/***/ 3220: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -94281,7 +99405,7 @@ var EElistenerCount = function EElistenerCount(emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(36442); +var Stream = __nccwpck_require__(83703); /**/ var Buffer = (__nccwpck_require__(14300).Buffer); @@ -94303,11 +99427,11 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(58985); -var destroyImpl = __nccwpck_require__(17582); -var _require = __nccwpck_require__(12188), +var BufferList = __nccwpck_require__(17008); +var destroyImpl = __nccwpck_require__(46630); +var _require = __nccwpck_require__(72565), getHighWaterMark = _require.getHighWaterMark; -var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(20458)/* .codes */ .q), ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, @@ -94317,7 +99441,7 @@ var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), var StringDecoder; var createReadableStreamAsyncIterator; var from; -__nccwpck_require__(42991)(Readable, Stream); +__nccwpck_require__(56779)(Readable, Stream); var errorOrDestroy = destroyImpl.errorOrDestroy; var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; function prependListener(emitter, event, fn) { @@ -94332,7 +99456,7 @@ function prependListener(emitter, event, fn) { if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; } function ReadableState(options, stream, isDuplex) { - Duplex = Duplex || __nccwpck_require__(47116); + Duplex = Duplex || __nccwpck_require__(50502); options = options || {}; // Duplex streams are both readable and writable, but share @@ -94399,13 +99523,13 @@ function ReadableState(options, stream, isDuplex) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(35263)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(42768)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(47116); + Duplex = Duplex || __nccwpck_require__(50502); if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside @@ -94542,7 +99666,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(35263)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(42768)/* .StringDecoder */ .s); var decoder = new StringDecoder(enc); this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8 @@ -95161,7 +100285,7 @@ Readable.prototype.wrap = function (stream) { if (typeof Symbol === 'function') { Readable.prototype[Symbol.asyncIterator] = function () { if (createReadableStreamAsyncIterator === undefined) { - createReadableStreamAsyncIterator = __nccwpck_require__(49107); + createReadableStreamAsyncIterator = __nccwpck_require__(43688); } return createReadableStreamAsyncIterator(this); }; @@ -95258,7 +100382,7 @@ function endReadableNT(state, stream) { if (typeof Symbol === 'function') { Readable.from = function (iterable, opts) { if (from === undefined) { - from = __nccwpck_require__(81245); + from = __nccwpck_require__(77275); } return from(Readable, iterable, opts); }; @@ -95272,7 +100396,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 176: +/***/ 62065: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -95342,13 +100466,13 @@ function indexOf(xs, x) { module.exports = Transform; -var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(20458)/* .codes */ .q), ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; -var Duplex = __nccwpck_require__(47116); -__nccwpck_require__(42991)(Transform, Duplex); +var Duplex = __nccwpck_require__(50502); +__nccwpck_require__(56779)(Transform, Duplex); function afterTransform(er, data) { var ts = this._transformState; ts.transforming = false; @@ -95469,7 +100593,7 @@ function done(stream, er, data) { /***/ }), -/***/ 90205: +/***/ 49105: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -95530,12 +100654,12 @@ Writable.WritableState = WritableState; /**/ var internalUtil = { - deprecate: __nccwpck_require__(98485) + deprecate: __nccwpck_require__(20524) }; /**/ /**/ -var Stream = __nccwpck_require__(36442); +var Stream = __nccwpck_require__(83703); /**/ var Buffer = (__nccwpck_require__(14300).Buffer); @@ -95546,10 +100670,10 @@ function _uint8ArrayToBuffer(chunk) { function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } -var destroyImpl = __nccwpck_require__(17582); -var _require = __nccwpck_require__(12188), +var destroyImpl = __nccwpck_require__(46630); +var _require = __nccwpck_require__(72565), getHighWaterMark = _require.getHighWaterMark; -var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(20458)/* .codes */ .q), ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, @@ -95559,10 +100683,10 @@ var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; var errorOrDestroy = destroyImpl.errorOrDestroy; -__nccwpck_require__(42991)(Writable, Stream); +__nccwpck_require__(56779)(Writable, Stream); function nop() {} function WritableState(options, stream, isDuplex) { - Duplex = Duplex || __nccwpck_require__(47116); + Duplex = Duplex || __nccwpck_require__(50502); options = options || {}; // Duplex streams are both readable and writable, but share @@ -95704,7 +100828,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot }; } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(47116); + Duplex = Duplex || __nccwpck_require__(50502); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -96117,7 +101241,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 49107: +/***/ 43688: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -96127,7 +101251,7 @@ var _Object$setPrototypeO; function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } -var finished = __nccwpck_require__(79371); +var finished = __nccwpck_require__(10997); var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); @@ -96304,7 +101428,7 @@ module.exports = createReadableStreamAsyncIterator; /***/ }), -/***/ 58985: +/***/ 17008: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -96494,7 +101618,7 @@ module.exports = /*#__PURE__*/function () { /***/ }), -/***/ 17582: +/***/ 46630: /***/ ((module) => { "use strict"; @@ -96597,7 +101721,7 @@ module.exports = { /***/ }), -/***/ 79371: +/***/ 10997: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -96606,7 +101730,7 @@ module.exports = { -var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(17778)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); +var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(20458)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); function once(callback) { var called = false; return function () { @@ -96690,7 +101814,7 @@ module.exports = eos; /***/ }), -/***/ 81245: +/***/ 77275: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -96703,7 +101827,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } -var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(17778)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE); +var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(20458)/* .codes.ERR_INVALID_ARG_TYPE */ .q.ERR_INVALID_ARG_TYPE); function from(Readable, iterable, opts) { var iterator; if (iterable && typeof iterable.next === 'function') { @@ -96750,7 +101874,7 @@ module.exports = from; /***/ }), -/***/ 45987: +/***/ 25720: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -96768,7 +101892,7 @@ function once(callback) { callback.apply(void 0, arguments); }; } -var _require$codes = (__nccwpck_require__(17778)/* .codes */ .q), +var _require$codes = (__nccwpck_require__(20458)/* .codes */ .q), ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; function noop(err) { @@ -96784,7 +101908,7 @@ function destroyer(stream, reading, writing, callback) { stream.on('close', function () { closed = true; }); - if (eos === undefined) eos = __nccwpck_require__(79371); + if (eos === undefined) eos = __nccwpck_require__(10997); eos(stream, { readable: reading, writable: writing @@ -96843,13 +101967,13 @@ module.exports = pipeline; /***/ }), -/***/ 12188: +/***/ 72565: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(17778)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE); +var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(20458)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE); function highWaterMarkFrom(options, isDuplex, duplexKey) { return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; } @@ -96872,7 +101996,7 @@ module.exports = { /***/ }), -/***/ 36442: +/***/ 83703: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -96880,7 +102004,7 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 84123: +/***/ 96788: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -96889,28 +102013,28 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { Object.assign(module.exports, Stream); module.exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(43170); + exports = module.exports = __nccwpck_require__(3220); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(90205); - exports.Duplex = __nccwpck_require__(47116); - exports.Transform = __nccwpck_require__(176); - exports.PassThrough = __nccwpck_require__(63515); - exports.finished = __nccwpck_require__(79371); - exports.pipeline = __nccwpck_require__(45987); + exports.Writable = __nccwpck_require__(49105); + exports.Duplex = __nccwpck_require__(50502); + exports.Transform = __nccwpck_require__(62065); + exports.PassThrough = __nccwpck_require__(11076); + exports.finished = __nccwpck_require__(10997); + exports.pipeline = __nccwpck_require__(25720); } /***/ }), -/***/ 84797: +/***/ 49833: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = readdirGlob; const fs = __nccwpck_require__(57147); const { EventEmitter } = __nccwpck_require__(82361); -const { Minimatch } = __nccwpck_require__(70631); +const { Minimatch } = __nccwpck_require__(96479); const { resolve } = __nccwpck_require__(71017); function readdir(dir, strict) { @@ -97152,10 +102276,10 @@ readdirGlob.ReaddirGlob = ReaddirGlob; /***/ }), -/***/ 22417: +/***/ 2721: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var balanced = __nccwpck_require__(89948); +var balanced = __nccwpck_require__(88378); module.exports = expandTop; @@ -97362,7 +102486,7 @@ function expand(str, isTop) { /***/ }), -/***/ 76241: +/***/ 84375: /***/ ((module) => { const isWindows = typeof process === 'object' && @@ -97373,7 +102497,7 @@ module.exports = isWindows ? { sep: '\\' } : { sep: '/' } /***/ }), -/***/ 70631: +/***/ 96479: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const minimatch = module.exports = (p, pattern, options = {}) => { @@ -97389,12 +102513,12 @@ const minimatch = module.exports = (p, pattern, options = {}) => { module.exports = minimatch -const path = __nccwpck_require__(76241) +const path = __nccwpck_require__(84375) minimatch.sep = path.sep const GLOBSTAR = Symbol('globstar **') minimatch.GLOBSTAR = GLOBSTAR -const expand = __nccwpck_require__(22417) +const expand = __nccwpck_require__(2721) const plTypes = { '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, @@ -98324,7 +103448,7 @@ minimatch.Minimatch = Minimatch /***/ }), -/***/ 9651: +/***/ 51133: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = rimraf @@ -98335,7 +103459,7 @@ var path = __nccwpck_require__(71017) var fs = __nccwpck_require__(57147) var glob = undefined try { - glob = __nccwpck_require__(3661) + glob = __nccwpck_require__(19830) } catch (_err) { // treat glob as optional. } @@ -98703,7 +103827,7 @@ function rmkidsSync (p, options) { /***/ }), -/***/ 85537: +/***/ 10408: /***/ ((module, exports, __nccwpck_require__) => { /*! safe-buffer. MIT License. Feross Aboukhadijeh */ @@ -98775,7 +103899,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 77400: +/***/ 44642: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { ;(function (sax) { // wrapper for non-node envs @@ -100347,7 +105471,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 18690: +/***/ 41146: /***/ (function() { (function (global, undefined) { @@ -100540,7 +105664,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 35263: +/***/ 42768: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -100569,7 +105693,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /**/ -var Buffer = (__nccwpck_require__(85537).Buffer); +var Buffer = (__nccwpck_require__(10408).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -100843,15 +105967,15 @@ function simpleEnd(buf) { /***/ }), -/***/ 1356: +/***/ 39247: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(73837) -var bl = __nccwpck_require__(69056) -var headers = __nccwpck_require__(16241) +var bl = __nccwpck_require__(55101) +var headers = __nccwpck_require__(33058) -var Writable = (__nccwpck_require__(84123).Writable) -var PassThrough = (__nccwpck_require__(84123).PassThrough) +var Writable = (__nccwpck_require__(96788).Writable) +var PassThrough = (__nccwpck_require__(96788).PassThrough) var noop = function () {} @@ -101107,7 +106231,7 @@ module.exports = Extract /***/ }), -/***/ 16241: +/***/ 33058: /***/ ((__unused_webpack_module, exports) => { var alloc = Buffer.alloc @@ -101409,28 +106533,28 @@ exports.decode = function (buf, filenameEncoding, allowUnknownFormat) { /***/ }), -/***/ 69658: +/***/ 45776: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -exports.extract = __nccwpck_require__(1356) -exports.pack = __nccwpck_require__(36981) +exports.extract = __nccwpck_require__(39247) +exports.pack = __nccwpck_require__(27204) /***/ }), -/***/ 36981: +/***/ 27204: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var constants = __nccwpck_require__(53370) -var eos = __nccwpck_require__(95688) -var inherits = __nccwpck_require__(42991) +var constants = __nccwpck_require__(41475) +var eos = __nccwpck_require__(60522) +var inherits = __nccwpck_require__(56779) var alloc = Buffer.alloc -var Readable = (__nccwpck_require__(84123).Readable) -var Writable = (__nccwpck_require__(84123).Writable) +var Readable = (__nccwpck_require__(96788).Readable) +var Writable = (__nccwpck_require__(96788).Writable) var StringDecoder = (__nccwpck_require__(71576).StringDecoder) -var headers = __nccwpck_require__(16241) +var headers = __nccwpck_require__(33058) var DMODE = parseInt('755', 8) var FMODE = parseInt('644', 8) @@ -101680,14 +106804,14 @@ module.exports = Pack /***/ }), -/***/ 77151: +/***/ 63604: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; var punycode = __nccwpck_require__(85477); -var mappingTable = __nccwpck_require__(99022); +var mappingTable = __nccwpck_require__(68865); var PROCESSING_OPTIONS = { TRANSITIONAL: 0, @@ -101881,7 +107005,7 @@ module.exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS; /***/ }), -/***/ 24203: +/***/ 79244: /***/ ((module) => { module.exports = Traverse; @@ -102210,7 +107334,7 @@ function copy (src) { /***/ }), -/***/ 92716: +/***/ 89027: /***/ ((module) => { /****************************************************************************** @@ -102638,15 +107762,15 @@ var __disposeResources; /***/ }), -/***/ 20791: +/***/ 88593: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(92980); +module.exports = __nccwpck_require__(21378); /***/ }), -/***/ 92980: +/***/ 21378: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -102918,7 +108042,7 @@ exports.debug = debug; // for test /***/ }), -/***/ 30227: +/***/ 58519: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -102928,7 +108052,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); /***/ }), -/***/ 19730: +/***/ 86889: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -103207,7 +108331,7 @@ exports.isValidErrorCode = isValidErrorCode; /***/ }), -/***/ 99475: +/***/ 14447: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -103254,11 +108378,11 @@ var __rest = (this && this.__rest) || function (s, e) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.Gateway = exports.Pattern = void 0; const querystring_1 = __nccwpck_require__(63477); -const dotObject = __importStar(__nccwpck_require__(91205)); -const request_1 = __nccwpck_require__(67924); -const errors_1 = __nccwpck_require__(19730); -const http_client_1 = __nccwpck_require__(5443); -const server_1 = __nccwpck_require__(76591); +const dotObject = __importStar(__nccwpck_require__(46037)); +const request_1 = __nccwpck_require__(43257); +const errors_1 = __nccwpck_require__(86889); +const http_client_1 = __nccwpck_require__(48469); +const server_1 = __nccwpck_require__(38389); var Pattern; (function (Pattern) { Pattern["POST"] = "post"; @@ -103422,7 +108546,7 @@ exports.Gateway = Gateway; /***/ }), -/***/ 47931: +/***/ 2045: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -103544,7 +108668,7 @@ exports.isHook = isHook; /***/ }), -/***/ 5443: +/***/ 48469: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -103582,7 +108706,7 @@ exports.FetchRPC = exports.wrapErrorResponseToTwirpError = exports.NodeHttpRPC = const http = __importStar(__nccwpck_require__(13685)); const https = __importStar(__nccwpck_require__(95687)); const url_1 = __nccwpck_require__(57310); -const errors_1 = __nccwpck_require__(19730); +const errors_1 = __nccwpck_require__(86889); /** * a node HTTP RPC implementation * @param options @@ -103664,7 +108788,7 @@ exports.FetchRPC = FetchRPC; /***/ }), -/***/ 68053: +/***/ 76676: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -103681,20 +108805,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) { }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.TwirpContentType = void 0; -__exportStar(__nccwpck_require__(30227), exports); -__exportStar(__nccwpck_require__(76591), exports); -__exportStar(__nccwpck_require__(18373), exports); -__exportStar(__nccwpck_require__(47931), exports); -__exportStar(__nccwpck_require__(19730), exports); -__exportStar(__nccwpck_require__(99475), exports); -__exportStar(__nccwpck_require__(5443), exports); -var request_1 = __nccwpck_require__(67924); +__exportStar(__nccwpck_require__(58519), exports); +__exportStar(__nccwpck_require__(38389), exports); +__exportStar(__nccwpck_require__(17047), exports); +__exportStar(__nccwpck_require__(2045), exports); +__exportStar(__nccwpck_require__(86889), exports); +__exportStar(__nccwpck_require__(14447), exports); +__exportStar(__nccwpck_require__(48469), exports); +var request_1 = __nccwpck_require__(43257); Object.defineProperty(exports, "TwirpContentType", ({ enumerable: true, get: function () { return request_1.TwirpContentType; } })); /***/ }), -/***/ 18373: +/***/ 17047: /***/ (function(__unused_webpack_module, exports) { "use strict"; @@ -103736,7 +108860,7 @@ exports.chainInterceptors = chainInterceptors; /***/ }), -/***/ 67924: +/***/ 43257: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -103752,7 +108876,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.parseTwirpPath = exports.getRequestData = exports.validateRequest = exports.getContentType = exports.TwirpContentType = void 0; -const errors_1 = __nccwpck_require__(19730); +const errors_1 = __nccwpck_require__(86889); /** * Supported Twirp Content-Type */ @@ -103861,7 +108985,7 @@ exports.parseTwirpPath = parseTwirpPath; /***/ }), -/***/ 76591: +/***/ 38389: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -103877,9 +109001,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); exports.writeError = exports.TwirpServer = void 0; -const hooks_1 = __nccwpck_require__(47931); -const request_1 = __nccwpck_require__(67924); -const errors_1 = __nccwpck_require__(19730); +const hooks_1 = __nccwpck_require__(2045); +const request_1 = __nccwpck_require__(43257); +const errors_1 = __nccwpck_require__(86889); /** * Runtime server implementation of a TwirpServer */ @@ -104064,7 +109188,7 @@ function mustBeTwirpError(err) { /***/ }), -/***/ 68636: +/***/ 40996: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -104090,7 +109214,7 @@ exports.getUserAgent = getUserAgent; /***/ }), -/***/ 81894: +/***/ 85610: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Buffer = (__nccwpck_require__(14300).Buffer); @@ -104108,16 +109232,16 @@ module.exports = Buffer; /***/ }), -/***/ 98878: +/***/ 36024: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var Promise = __nccwpck_require__(94453); +var Promise = __nccwpck_require__(36044); var Stream = __nccwpck_require__(12781); -var Buffer = __nccwpck_require__(81894); +var Buffer = __nccwpck_require__(85610); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); module.exports = function(entry) { return new Promise(function(resolve,reject) { @@ -104140,15 +109264,15 @@ module.exports = function(entry) { /***/ }), -/***/ 34025: +/***/ 28644: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var bigInt = __nccwpck_require__(34312); +var bigInt = __nccwpck_require__(4795); var Stream = __nccwpck_require__(12781); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); var table; @@ -104218,7 +109342,7 @@ module.exports = Decrypt; /***/ }), -/***/ 137: +/***/ 61645: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -104226,7 +109350,7 @@ var util = __nccwpck_require__(73837); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); function NoopStream() { if (!(this instanceof NoopStream)) { @@ -104243,19 +109367,19 @@ module.exports = NoopStream; /***/ }), -/***/ 2283: +/***/ 58549: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var binary = __nccwpck_require__(59099); -var PullStream = __nccwpck_require__(48598); -var unzip = __nccwpck_require__(48365); -var Promise = __nccwpck_require__(94453); -var BufferStream = __nccwpck_require__(98878); -var parseExtraField = __nccwpck_require__(95614); -var Buffer = __nccwpck_require__(81894); +var binary = __nccwpck_require__(21829); +var PullStream = __nccwpck_require__(44239); +var unzip = __nccwpck_require__(62522); +var Promise = __nccwpck_require__(36044); +var BufferStream = __nccwpck_require__(36024); +var parseExtraField = __nccwpck_require__(35565); +var Buffer = __nccwpck_require__(85610); var path = __nccwpck_require__(71017); -var Writer = (__nccwpck_require__(45694).Writer); -var parseDateTime = __nccwpck_require__(24303); +var Writer = (__nccwpck_require__(31382).Writer); +var parseDateTime = __nccwpck_require__(76668); var signature = Buffer.alloc(4); signature.writeUInt32LE(0x06054b50,0); @@ -104481,17 +109605,17 @@ module.exports = function centralDirectory(source, options) { /***/ }), -/***/ 29359: +/***/ 2945: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var fs = __nccwpck_require__(91468); -var Promise = __nccwpck_require__(94453); -var directory = __nccwpck_require__(2283); +var fs = __nccwpck_require__(80759); +var Promise = __nccwpck_require__(36044); +var directory = __nccwpck_require__(58549); var Stream = __nccwpck_require__(12781); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); module.exports = { buffer: function(buffer, options) { @@ -104589,22 +109713,22 @@ module.exports = { /***/ }), -/***/ 48365: +/***/ 62522: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var Promise = __nccwpck_require__(94453); -var Decrypt = __nccwpck_require__(34025); -var PullStream = __nccwpck_require__(48598); +var Promise = __nccwpck_require__(36044); +var Decrypt = __nccwpck_require__(28644); +var PullStream = __nccwpck_require__(44239); var Stream = __nccwpck_require__(12781); -var binary = __nccwpck_require__(59099); +var binary = __nccwpck_require__(21829); var zlib = __nccwpck_require__(59796); -var parseExtraField = __nccwpck_require__(95614); -var Buffer = __nccwpck_require__(81894); -var parseDateTime = __nccwpck_require__(24303); +var parseExtraField = __nccwpck_require__(35565); +var Buffer = __nccwpck_require__(85610); +var parseDateTime = __nccwpck_require__(76668); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); module.exports = function unzip(source,offset,_password, directoryVars) { var file = PullStream(), @@ -104722,18 +109846,18 @@ module.exports = function unzip(source,offset,_password, directoryVars) { /***/ }), -/***/ 48598: +/***/ 44239: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); -var Promise = __nccwpck_require__(94453); +var Promise = __nccwpck_require__(36044); var util = __nccwpck_require__(73837); -var Buffer = __nccwpck_require__(81894); +var Buffer = __nccwpck_require__(85610); var strFunction = 'function'; // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); function PullStream() { if (!(this instanceof PullStream)) @@ -104873,17 +109997,17 @@ module.exports = PullStream; /***/ }), -/***/ 50956: +/***/ 12857: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = Extract; -var Parse = __nccwpck_require__(10999); -var Writer = (__nccwpck_require__(45694).Writer); +var Parse = __nccwpck_require__(74162); +var Writer = (__nccwpck_require__(31382).Writer); var path = __nccwpck_require__(71017); var stream = __nccwpck_require__(12781); -var duplexer2 = __nccwpck_require__(90679); -var Promise = __nccwpck_require__(94453); +var duplexer2 = __nccwpck_require__(86189); +var Promise = __nccwpck_require__(36044); function Extract (opts) { // make sure path is normalized before using it @@ -104935,24 +110059,24 @@ function Extract (opts) { /***/ }), -/***/ 10999: +/***/ 74162: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(73837); var zlib = __nccwpck_require__(59796); var Stream = __nccwpck_require__(12781); -var binary = __nccwpck_require__(59099); -var Promise = __nccwpck_require__(94453); -var PullStream = __nccwpck_require__(48598); -var NoopStream = __nccwpck_require__(137); -var BufferStream = __nccwpck_require__(98878); -var parseExtraField = __nccwpck_require__(95614); -var Buffer = __nccwpck_require__(81894); -var parseDateTime = __nccwpck_require__(24303); +var binary = __nccwpck_require__(21829); +var Promise = __nccwpck_require__(36044); +var PullStream = __nccwpck_require__(44239); +var NoopStream = __nccwpck_require__(61645); +var BufferStream = __nccwpck_require__(36024); +var parseExtraField = __nccwpck_require__(35565); +var Buffer = __nccwpck_require__(85610); +var parseDateTime = __nccwpck_require__(76668); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); var endDirectorySignature = Buffer.alloc(4); endDirectorySignature.writeUInt32LE(0x06054b50, 0); @@ -105229,7 +110353,7 @@ module.exports = Parse; /***/ }), -/***/ 24303: +/***/ 76668: /***/ ((module) => { // Dates in zip file entries are stored as DosDateTime @@ -105248,10 +110372,10 @@ module.exports = function parseDateTime(date, time) { /***/ }), -/***/ 95614: +/***/ 35565: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var binary = __nccwpck_require__(59099); +var binary = __nccwpck_require__(21829); module.exports = function(extraField, vars) { var extra; @@ -105292,17 +110416,17 @@ module.exports = function(extraField, vars) { /***/ }), -/***/ 64154: +/***/ 28559: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); -var Parse = __nccwpck_require__(10999); -var duplexer2 = __nccwpck_require__(90679); -var BufferStream = __nccwpck_require__(98878); +var Parse = __nccwpck_require__(74162); +var duplexer2 = __nccwpck_require__(86189); +var BufferStream = __nccwpck_require__(36024); // Backwards compatibility for node versions < 8 if (!Stream.Writable || !Stream.Writable.prototype.destroy) - Stream = __nccwpck_require__(56026); + Stream = __nccwpck_require__(86545); function parseOne(match,opts) { var inStream = Stream.PassThrough({objectMode:true}); @@ -105357,7 +110481,7 @@ module.exports = parseOne; /***/ }), -/***/ 75089: +/***/ 53331: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -105391,7 +110515,7 @@ module.exports = parseOne; /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ /**/ @@ -105406,12 +110530,12 @@ var objectKeys = Object.keys || function (obj) { module.exports = Duplex; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ -var Readable = __nccwpck_require__(80273); -var Writable = __nccwpck_require__(74559); +var Readable = __nccwpck_require__(8265); +var Writable = __nccwpck_require__(63942); util.inherits(Duplex, Readable); @@ -105495,7 +110619,7 @@ Duplex.prototype._destroy = function (err, cb) { /***/ }), -/***/ 946: +/***/ 91059: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -105528,11 +110652,11 @@ Duplex.prototype._destroy = function (err, cb) { module.exports = PassThrough; -var Transform = __nccwpck_require__(9094); +var Transform = __nccwpck_require__(89249); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(PassThrough, Transform); @@ -105549,7 +110673,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /***/ }), -/***/ 80273: +/***/ 8265: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -105578,13 +110702,13 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Readable; /**/ -var isArray = __nccwpck_require__(80456); +var isArray = __nccwpck_require__(77751); /**/ /**/ @@ -105602,12 +110726,12 @@ var EElistenerCount = function (emitter, type) { /**/ /**/ -var Stream = __nccwpck_require__(93287); +var Stream = __nccwpck_require__(1602); /**/ /**/ -var Buffer = (__nccwpck_require__(72828).Buffer); +var Buffer = (__nccwpck_require__(582).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -105619,8 +110743,8 @@ function _isUint8Array(obj) { /**/ /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ @@ -105633,8 +110757,8 @@ if (debugUtil && debugUtil.debuglog) { } /**/ -var BufferList = __nccwpck_require__(15560); -var destroyImpl = __nccwpck_require__(20604); +var BufferList = __nccwpck_require__(11567); +var destroyImpl = __nccwpck_require__(94234); var StringDecoder; util.inherits(Readable, Stream); @@ -105654,7 +110778,7 @@ function prependListener(emitter, event, fn) { } function ReadableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(75089); + Duplex = Duplex || __nccwpck_require__(53331); options = options || {}; @@ -105724,14 +110848,14 @@ function ReadableState(options, stream) { this.decoder = null; this.encoding = null; if (options.encoding) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(63822)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(47602)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } function Readable(options) { - Duplex = Duplex || __nccwpck_require__(75089); + Duplex = Duplex || __nccwpck_require__(53331); if (!(this instanceof Readable)) return new Readable(options); @@ -105880,7 +111004,7 @@ Readable.prototype.isPaused = function () { // backwards compatibility. Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = (__nccwpck_require__(63822)/* .StringDecoder */ .s); + if (!StringDecoder) StringDecoder = (__nccwpck_require__(47602)/* .StringDecoder */ .s); this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; @@ -106575,7 +111699,7 @@ function indexOf(xs, x) { /***/ }), -/***/ 9094: +/***/ 89249: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -106646,11 +111770,11 @@ function indexOf(xs, x) { module.exports = Transform; -var Duplex = __nccwpck_require__(75089); +var Duplex = __nccwpck_require__(53331); /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ util.inherits(Transform, Duplex); @@ -106796,7 +111920,7 @@ function done(stream, er, data) { /***/ }), -/***/ 74559: +/***/ 63942: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -106829,7 +111953,7 @@ function done(stream, er, data) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ module.exports = Writable; @@ -106866,23 +111990,23 @@ var Duplex; Writable.WritableState = WritableState; /**/ -var util = Object.create(__nccwpck_require__(32137)); -util.inherits = __nccwpck_require__(42991); +var util = Object.create(__nccwpck_require__(64601)); +util.inherits = __nccwpck_require__(56779); /**/ /**/ var internalUtil = { - deprecate: __nccwpck_require__(98485) + deprecate: __nccwpck_require__(20524) }; /**/ /**/ -var Stream = __nccwpck_require__(93287); +var Stream = __nccwpck_require__(1602); /**/ /**/ -var Buffer = (__nccwpck_require__(72828).Buffer); +var Buffer = (__nccwpck_require__(582).Buffer); var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); @@ -106893,14 +112017,14 @@ function _isUint8Array(obj) { /**/ -var destroyImpl = __nccwpck_require__(20604); +var destroyImpl = __nccwpck_require__(94234); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { - Duplex = Duplex || __nccwpck_require__(75089); + Duplex = Duplex || __nccwpck_require__(53331); options = options || {}; @@ -107050,7 +112174,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot } function Writable(options) { - Duplex = Duplex || __nccwpck_require__(75089); + Duplex = Duplex || __nccwpck_require__(53331); // Writable ctor is applied to Duplexes, too. // `realHasInstance` is necessary because using plain `instanceof` @@ -107488,7 +112612,7 @@ Writable.prototype._destroy = function (err, cb) { /***/ }), -/***/ 15560: +/***/ 11567: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -107496,7 +112620,7 @@ Writable.prototype._destroy = function (err, cb) { function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var Buffer = (__nccwpck_require__(72828).Buffer); +var Buffer = (__nccwpck_require__(582).Buffer); var util = __nccwpck_require__(73837); function copyBuffer(src, target, offset) { @@ -107573,7 +112697,7 @@ if (util && util.inspect && util.inspect.custom) { /***/ }), -/***/ 20604: +/***/ 94234: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -107581,7 +112705,7 @@ if (util && util.inspect && util.inspect.custom) { /**/ -var pna = __nccwpck_require__(13817); +var pna = __nccwpck_require__(26314); /**/ // undocumented cb() API, needed for core, not for public API @@ -107664,7 +112788,7 @@ module.exports = { /***/ }), -/***/ 93287: +/***/ 1602: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = __nccwpck_require__(12781); @@ -107672,7 +112796,7 @@ module.exports = __nccwpck_require__(12781); /***/ }), -/***/ 56026: +/***/ 86545: /***/ ((module, exports, __nccwpck_require__) => { var Stream = __nccwpck_require__(12781); @@ -107686,19 +112810,19 @@ if (process.env.READABLE_STREAM === 'disable' && Stream) { exports.PassThrough = Stream.PassThrough; exports.Stream = Stream; } else { - exports = module.exports = __nccwpck_require__(80273); + exports = module.exports = __nccwpck_require__(8265); exports.Stream = Stream || exports; exports.Readable = exports; - exports.Writable = __nccwpck_require__(74559); - exports.Duplex = __nccwpck_require__(75089); - exports.Transform = __nccwpck_require__(9094); - exports.PassThrough = __nccwpck_require__(946); + exports.Writable = __nccwpck_require__(63942); + exports.Duplex = __nccwpck_require__(53331); + exports.Transform = __nccwpck_require__(89249); + exports.PassThrough = __nccwpck_require__(91059); } /***/ }), -/***/ 72828: +/***/ 582: /***/ ((module, exports, __nccwpck_require__) => { /* eslint-disable node/no-deprecated-api */ @@ -107767,7 +112891,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 63822: +/***/ 47602: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -107796,7 +112920,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /**/ -var Buffer = (__nccwpck_require__(72828).Buffer); +var Buffer = (__nccwpck_require__(582).Buffer); /**/ var isEncoding = Buffer.isEncoding || function (encoding) { @@ -108070,25 +113194,25 @@ function simpleEnd(buf) { /***/ }), -/***/ 80686: +/***/ 36827: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; // Polyfills for node 0.8 -__nccwpck_require__(70891); -__nccwpck_require__(91361); -__nccwpck_require__(18690); +__nccwpck_require__(51362); +__nccwpck_require__(35843); +__nccwpck_require__(41146); -exports.Parse = __nccwpck_require__(10999); -exports.ParseOne = __nccwpck_require__(64154); -exports.Extract = __nccwpck_require__(50956); -exports.Open = __nccwpck_require__(29359); +exports.Parse = __nccwpck_require__(74162); +exports.ParseOne = __nccwpck_require__(28559); +exports.Extract = __nccwpck_require__(12857); +exports.Open = __nccwpck_require__(2945); /***/ }), -/***/ 98485: +/***/ 20524: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { @@ -108101,7 +113225,7 @@ module.exports = __nccwpck_require__(73837).deprecate; /***/ }), -/***/ 4413: +/***/ 27405: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108165,29 +113289,29 @@ Object.defineProperty(exports, "parse", ({ } })); -var _v = _interopRequireDefault(__nccwpck_require__(66602)); +var _v = _interopRequireDefault(__nccwpck_require__(64154)); -var _v2 = _interopRequireDefault(__nccwpck_require__(81708)); +var _v2 = _interopRequireDefault(__nccwpck_require__(4886)); -var _v3 = _interopRequireDefault(__nccwpck_require__(48672)); +var _v3 = _interopRequireDefault(__nccwpck_require__(31170)); -var _v4 = _interopRequireDefault(__nccwpck_require__(72264)); +var _v4 = _interopRequireDefault(__nccwpck_require__(13013)); -var _nil = _interopRequireDefault(__nccwpck_require__(43732)); +var _nil = _interopRequireDefault(__nccwpck_require__(58234)); -var _version = _interopRequireDefault(__nccwpck_require__(14413)); +var _version = _interopRequireDefault(__nccwpck_require__(75493)); -var _validate = _interopRequireDefault(__nccwpck_require__(86912)); +var _validate = _interopRequireDefault(__nccwpck_require__(59641)); -var _stringify = _interopRequireDefault(__nccwpck_require__(10347)); +var _stringify = _interopRequireDefault(__nccwpck_require__(47312)); -var _parse = _interopRequireDefault(__nccwpck_require__(48059)); +var _parse = _interopRequireDefault(__nccwpck_require__(16546)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } /***/ }), -/***/ 34135: +/***/ 43569: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108217,7 +113341,7 @@ exports["default"] = _default; /***/ }), -/***/ 43732: +/***/ 58234: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -108232,7 +113356,7 @@ exports["default"] = _default; /***/ }), -/***/ 48059: +/***/ 16546: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108243,7 +113367,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(86912)); +var _validate = _interopRequireDefault(__nccwpck_require__(59641)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108284,7 +113408,7 @@ exports["default"] = _default; /***/ }), -/***/ 55630: +/***/ 5386: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -108299,7 +113423,7 @@ exports["default"] = _default; /***/ }), -/***/ 61165: +/***/ 54188: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108330,7 +113454,7 @@ function rng() { /***/ }), -/***/ 81857: +/***/ 36057: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108360,7 +113484,7 @@ exports["default"] = _default; /***/ }), -/***/ 10347: +/***/ 47312: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108371,7 +113495,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(86912)); +var _validate = _interopRequireDefault(__nccwpck_require__(59641)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108406,7 +113530,7 @@ exports["default"] = _default; /***/ }), -/***/ 66602: +/***/ 64154: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108417,9 +113541,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _rng = _interopRequireDefault(__nccwpck_require__(61165)); +var _rng = _interopRequireDefault(__nccwpck_require__(54188)); -var _stringify = _interopRequireDefault(__nccwpck_require__(10347)); +var _stringify = _interopRequireDefault(__nccwpck_require__(47312)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108520,7 +113644,7 @@ exports["default"] = _default; /***/ }), -/***/ 81708: +/***/ 4886: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108531,9 +113655,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(28617)); +var _v = _interopRequireDefault(__nccwpck_require__(79500)); -var _md = _interopRequireDefault(__nccwpck_require__(34135)); +var _md = _interopRequireDefault(__nccwpck_require__(43569)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108543,7 +113667,7 @@ exports["default"] = _default; /***/ }), -/***/ 28617: +/***/ 79500: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108555,9 +113679,9 @@ Object.defineProperty(exports, "__esModule", ({ exports["default"] = _default; exports.URL = exports.DNS = void 0; -var _stringify = _interopRequireDefault(__nccwpck_require__(10347)); +var _stringify = _interopRequireDefault(__nccwpck_require__(47312)); -var _parse = _interopRequireDefault(__nccwpck_require__(48059)); +var _parse = _interopRequireDefault(__nccwpck_require__(16546)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108628,7 +113752,7 @@ function _default(name, version, hashfunc) { /***/ }), -/***/ 48672: +/***/ 31170: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108639,9 +113763,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _rng = _interopRequireDefault(__nccwpck_require__(61165)); +var _rng = _interopRequireDefault(__nccwpck_require__(54188)); -var _stringify = _interopRequireDefault(__nccwpck_require__(10347)); +var _stringify = _interopRequireDefault(__nccwpck_require__(47312)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108672,7 +113796,7 @@ exports["default"] = _default; /***/ }), -/***/ 72264: +/***/ 13013: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108683,9 +113807,9 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _v = _interopRequireDefault(__nccwpck_require__(28617)); +var _v = _interopRequireDefault(__nccwpck_require__(79500)); -var _sha = _interopRequireDefault(__nccwpck_require__(81857)); +var _sha = _interopRequireDefault(__nccwpck_require__(36057)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108695,7 +113819,7 @@ exports["default"] = _default; /***/ }), -/***/ 86912: +/***/ 59641: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108706,7 +113830,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _regex = _interopRequireDefault(__nccwpck_require__(55630)); +var _regex = _interopRequireDefault(__nccwpck_require__(5386)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108719,7 +113843,7 @@ exports["default"] = _default; /***/ }), -/***/ 14413: +/***/ 75493: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -108730,7 +113854,7 @@ Object.defineProperty(exports, "__esModule", ({ })); exports["default"] = void 0; -var _validate = _interopRequireDefault(__nccwpck_require__(86912)); +var _validate = _interopRequireDefault(__nccwpck_require__(59641)); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } @@ -108747,7 +113871,7 @@ exports["default"] = _default; /***/ }), -/***/ 71834: +/***/ 9575: /***/ ((module) => { "use strict"; @@ -108944,12 +114068,12 @@ conversions["RegExp"] = function (V, opts) { /***/ }), -/***/ 65052: +/***/ 18811: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -const usm = __nccwpck_require__(96817); +const usm = __nccwpck_require__(72495); exports.implementation = class URLImpl { constructor(constructorArgs) { @@ -109152,15 +114276,15 @@ exports.implementation = class URLImpl { /***/ }), -/***/ 34499: +/***/ 70976: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -const conversions = __nccwpck_require__(71834); -const utils = __nccwpck_require__(73274); -const Impl = __nccwpck_require__(65052); +const conversions = __nccwpck_require__(9575); +const utils = __nccwpck_require__(63247); +const Impl = __nccwpck_require__(18811); const impl = utils.implSymbol; @@ -109356,32 +114480,32 @@ module.exports = { /***/ }), -/***/ 42801: +/***/ 18921: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -exports.URL = __nccwpck_require__(34499)["interface"]; -exports.serializeURL = __nccwpck_require__(96817).serializeURL; -exports.serializeURLOrigin = __nccwpck_require__(96817).serializeURLOrigin; -exports.basicURLParse = __nccwpck_require__(96817).basicURLParse; -exports.setTheUsername = __nccwpck_require__(96817).setTheUsername; -exports.setThePassword = __nccwpck_require__(96817).setThePassword; -exports.serializeHost = __nccwpck_require__(96817).serializeHost; -exports.serializeInteger = __nccwpck_require__(96817).serializeInteger; -exports.parseURL = __nccwpck_require__(96817).parseURL; +exports.URL = __nccwpck_require__(70976)["interface"]; +exports.serializeURL = __nccwpck_require__(72495).serializeURL; +exports.serializeURLOrigin = __nccwpck_require__(72495).serializeURLOrigin; +exports.basicURLParse = __nccwpck_require__(72495).basicURLParse; +exports.setTheUsername = __nccwpck_require__(72495).setTheUsername; +exports.setThePassword = __nccwpck_require__(72495).setThePassword; +exports.serializeHost = __nccwpck_require__(72495).serializeHost; +exports.serializeInteger = __nccwpck_require__(72495).serializeInteger; +exports.parseURL = __nccwpck_require__(72495).parseURL; /***/ }), -/***/ 96817: +/***/ 72495: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; const punycode = __nccwpck_require__(85477); -const tr46 = __nccwpck_require__(77151); +const tr46 = __nccwpck_require__(63604); const specialSchemes = { ftp: 21, @@ -110680,7 +115804,7 @@ module.exports.parseURL = function (input, options) { /***/ }), -/***/ 73274: +/***/ 63247: /***/ ((module) => { "use strict"; @@ -110708,7 +115832,7 @@ module.exports.implForWrapper = function (wrapper) { /***/ }), -/***/ 39148: +/***/ 3634: /***/ ((module) => { // Returns a wrapper function that returns a wrapped callback @@ -110748,7 +115872,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 35203: +/***/ 13599: /***/ (function(__unused_webpack_module, exports) { // Generated by CoffeeScript 1.12.7 @@ -110767,7 +115891,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 88883: +/***/ 30275: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -110776,9 +115900,9 @@ function wrappy (fn, cb) { var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA, hasProp = {}.hasOwnProperty; - builder = __nccwpck_require__(84537); + builder = __nccwpck_require__(16850); - defaults = (__nccwpck_require__(97731).defaults); + defaults = (__nccwpck_require__(33698).defaults); requiresCDATA = function(entry) { return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0); @@ -110901,7 +116025,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 97731: +/***/ 33698: /***/ (function(__unused_webpack_module, exports) { // Generated by CoffeeScript 1.12.7 @@ -110980,7 +116104,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 51414: +/***/ 96355: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -110991,17 +116115,17 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - sax = __nccwpck_require__(77400); + sax = __nccwpck_require__(44642); events = __nccwpck_require__(82361); - bom = __nccwpck_require__(35203); + bom = __nccwpck_require__(13599); - processors = __nccwpck_require__(88333); + processors = __nccwpck_require__(33340); setImmediate = (__nccwpck_require__(39512).setImmediate); - defaults = (__nccwpck_require__(97731).defaults); + defaults = (__nccwpck_require__(33698).defaults); isEmpty = function(thing) { return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0; @@ -111372,7 +116496,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 88333: +/***/ 33340: /***/ (function(__unused_webpack_module, exports) { // Generated by CoffeeScript 1.12.7 @@ -111413,7 +116537,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 50827: +/***/ 99440: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -111423,13 +116547,13 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - defaults = __nccwpck_require__(97731); + defaults = __nccwpck_require__(33698); - builder = __nccwpck_require__(88883); + builder = __nccwpck_require__(30275); - parser = __nccwpck_require__(51414); + parser = __nccwpck_require__(96355); - processors = __nccwpck_require__(88333); + processors = __nccwpck_require__(33340); exports.defaults = defaults.defaults; @@ -111459,7 +116583,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 52278: +/***/ 43411: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -111478,7 +116602,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 93480: +/***/ 21360: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -111508,7 +116632,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 49049: +/***/ 57205: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -111598,7 +116722,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 90168: +/***/ 78358: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -111615,16 +116739,16 @@ function wrappy (fn, cb) { /***/ }), -/***/ 68133: +/***/ 60572: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 (function() { var NodeType, XMLAttribute, XMLNode; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); module.exports = XMLAttribute = (function() { function XMLAttribute(parent, name, value) { @@ -111730,7 +116854,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 44695: +/***/ 80929: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -111739,9 +116863,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLCharacterData = __nccwpck_require__(16453); + XMLCharacterData = __nccwpck_require__(86306); module.exports = XMLCData = (function(superClass) { extend(XMLCData, superClass); @@ -111773,7 +116897,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 16453: +/***/ 86306: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -111782,7 +116906,7 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); module.exports = XMLCharacterData = (function(superClass) { extend(XMLCharacterData, superClass); @@ -111859,7 +116983,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 86312: +/***/ 32488: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -111868,9 +116992,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLCharacterData = __nccwpck_require__(16453); + XMLCharacterData = __nccwpck_require__(86306); module.exports = XMLComment = (function(superClass) { extend(XMLComment, superClass); @@ -111902,16 +117026,16 @@ function wrappy (fn, cb) { /***/ }), -/***/ 45600: +/***/ 66: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 (function() { var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList; - XMLDOMErrorHandler = __nccwpck_require__(18964); + XMLDOMErrorHandler = __nccwpck_require__(95558); - XMLDOMStringList = __nccwpck_require__(27355); + XMLDOMStringList = __nccwpck_require__(56506); module.exports = XMLDOMConfiguration = (function() { function XMLDOMConfiguration() { @@ -111973,7 +117097,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 18964: +/***/ 95558: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -111996,7 +117120,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 98926: +/***/ 76267: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -112035,7 +117159,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 27355: +/***/ 56506: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -112070,7 +117194,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 69535: +/***/ 10831: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112079,9 +117203,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDTDAttList = (function(superClass) { extend(XMLDTDAttList, superClass); @@ -112132,7 +117256,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 97648: +/***/ 10058: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112141,9 +117265,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDTDElement = (function(superClass) { extend(XMLDTDElement, superClass); @@ -112177,7 +117301,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 85257: +/***/ 57827: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112186,11 +117310,11 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - isObject = (__nccwpck_require__(49049).isObject); + isObject = (__nccwpck_require__(57205).isObject); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDTDEntity = (function(superClass) { extend(XMLDTDEntity, superClass); @@ -112281,7 +117405,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 2604: +/***/ 25985: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112290,9 +117414,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDTDNotation = (function(superClass) { extend(XMLDTDNotation, superClass); @@ -112340,7 +117464,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 99037: +/***/ 89921: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112349,11 +117473,11 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - isObject = (__nccwpck_require__(49049).isObject); + isObject = (__nccwpck_require__(57205).isObject); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDeclaration = (function(superClass) { extend(XMLDeclaration, superClass); @@ -112390,7 +117514,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 48815: +/***/ 30083: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112399,21 +117523,21 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - isObject = (__nccwpck_require__(49049).isObject); + isObject = (__nccwpck_require__(57205).isObject); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLDTDAttList = __nccwpck_require__(69535); + XMLDTDAttList = __nccwpck_require__(10831); - XMLDTDEntity = __nccwpck_require__(85257); + XMLDTDEntity = __nccwpck_require__(57827); - XMLDTDElement = __nccwpck_require__(97648); + XMLDTDElement = __nccwpck_require__(10058); - XMLDTDNotation = __nccwpck_require__(2604); + XMLDTDNotation = __nccwpck_require__(25985); - XMLNamedNodeMap = __nccwpck_require__(98725); + XMLNamedNodeMap = __nccwpck_require__(53370); module.exports = XMLDocType = (function(superClass) { extend(XMLDocType, superClass); @@ -112583,7 +117707,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 19258: +/***/ 64: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112592,19 +117716,19 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - isPlainObject = (__nccwpck_require__(49049).isPlainObject); + isPlainObject = (__nccwpck_require__(57205).isPlainObject); - XMLDOMImplementation = __nccwpck_require__(98926); + XMLDOMImplementation = __nccwpck_require__(76267); - XMLDOMConfiguration = __nccwpck_require__(45600); + XMLDOMConfiguration = __nccwpck_require__(66); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLStringifier = __nccwpck_require__(93841); + XMLStringifier = __nccwpck_require__(37188); - XMLStringWriter = __nccwpck_require__(91157); + XMLStringWriter = __nccwpck_require__(99182); module.exports = XMLDocument = (function(superClass) { extend(XMLDocument, superClass); @@ -112832,7 +117956,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 36237: +/***/ 34830: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -112840,43 +117964,43 @@ function wrappy (fn, cb) { var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref, hasProp = {}.hasOwnProperty; - ref = __nccwpck_require__(49049), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue; + ref = __nccwpck_require__(57205), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLDocument = __nccwpck_require__(19258); + XMLDocument = __nccwpck_require__(64); - XMLElement = __nccwpck_require__(91825); + XMLElement = __nccwpck_require__(12378); - XMLCData = __nccwpck_require__(44695); + XMLCData = __nccwpck_require__(80929); - XMLComment = __nccwpck_require__(86312); + XMLComment = __nccwpck_require__(32488); - XMLRaw = __nccwpck_require__(33923); + XMLRaw = __nccwpck_require__(13605); - XMLText = __nccwpck_require__(43611); + XMLText = __nccwpck_require__(5476); - XMLProcessingInstruction = __nccwpck_require__(91219); + XMLProcessingInstruction = __nccwpck_require__(66778); - XMLDeclaration = __nccwpck_require__(99037); + XMLDeclaration = __nccwpck_require__(89921); - XMLDocType = __nccwpck_require__(48815); + XMLDocType = __nccwpck_require__(30083); - XMLDTDAttList = __nccwpck_require__(69535); + XMLDTDAttList = __nccwpck_require__(10831); - XMLDTDEntity = __nccwpck_require__(85257); + XMLDTDEntity = __nccwpck_require__(57827); - XMLDTDElement = __nccwpck_require__(97648); + XMLDTDElement = __nccwpck_require__(10058); - XMLDTDNotation = __nccwpck_require__(2604); + XMLDTDNotation = __nccwpck_require__(25985); - XMLAttribute = __nccwpck_require__(68133); + XMLAttribute = __nccwpck_require__(60572); - XMLStringifier = __nccwpck_require__(93841); + XMLStringifier = __nccwpck_require__(37188); - XMLStringWriter = __nccwpck_require__(91157); + XMLStringWriter = __nccwpck_require__(99182); - WriterState = __nccwpck_require__(90168); + WriterState = __nccwpck_require__(78358); module.exports = XMLDocumentCB = (function() { function XMLDocumentCB(options, onData, onEnd) { @@ -113367,7 +118491,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 85043: +/***/ 69718: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -113376,9 +118500,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); module.exports = XMLDummy = (function(superClass) { extend(XMLDummy, superClass); @@ -113405,7 +118529,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 91825: +/***/ 12378: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -113414,15 +118538,15 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - ref = __nccwpck_require__(49049), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue; + ref = __nccwpck_require__(57205), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue; - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLAttribute = __nccwpck_require__(68133); + XMLAttribute = __nccwpck_require__(60572); - XMLNamedNodeMap = __nccwpck_require__(98725); + XMLNamedNodeMap = __nccwpck_require__(53370); module.exports = XMLElement = (function(superClass) { extend(XMLElement, superClass); @@ -113710,7 +118834,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 98725: +/***/ 53370: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -113775,7 +118899,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 86373: +/***/ 79925: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -113783,7 +118907,7 @@ function wrappy (fn, cb) { var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1, hasProp = {}.hasOwnProperty; - ref1 = __nccwpck_require__(49049), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue; + ref1 = __nccwpck_require__(57205), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue; XMLElement = null; @@ -113822,19 +118946,19 @@ function wrappy (fn, cb) { this.children = []; this.baseURI = null; if (!XMLElement) { - XMLElement = __nccwpck_require__(91825); - XMLCData = __nccwpck_require__(44695); - XMLComment = __nccwpck_require__(86312); - XMLDeclaration = __nccwpck_require__(99037); - XMLDocType = __nccwpck_require__(48815); - XMLRaw = __nccwpck_require__(33923); - XMLText = __nccwpck_require__(43611); - XMLProcessingInstruction = __nccwpck_require__(91219); - XMLDummy = __nccwpck_require__(85043); - NodeType = __nccwpck_require__(93480); - XMLNodeList = __nccwpck_require__(13897); - XMLNamedNodeMap = __nccwpck_require__(98725); - DocumentPosition = __nccwpck_require__(52278); + XMLElement = __nccwpck_require__(12378); + XMLCData = __nccwpck_require__(80929); + XMLComment = __nccwpck_require__(32488); + XMLDeclaration = __nccwpck_require__(89921); + XMLDocType = __nccwpck_require__(30083); + XMLRaw = __nccwpck_require__(13605); + XMLText = __nccwpck_require__(5476); + XMLProcessingInstruction = __nccwpck_require__(66778); + XMLDummy = __nccwpck_require__(69718); + NodeType = __nccwpck_require__(21360); + XMLNodeList = __nccwpck_require__(33980); + XMLNamedNodeMap = __nccwpck_require__(53370); + DocumentPosition = __nccwpck_require__(43411); } } @@ -114567,7 +119691,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 13897: +/***/ 33980: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -114602,7 +119726,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 91219: +/***/ 66778: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -114611,9 +119735,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLCharacterData = __nccwpck_require__(16453); + XMLCharacterData = __nccwpck_require__(86306); module.exports = XMLProcessingInstruction = (function(superClass) { extend(XMLProcessingInstruction, superClass); @@ -114658,7 +119782,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 33923: +/***/ 13605: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -114667,9 +119791,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLNode = __nccwpck_require__(86373); + XMLNode = __nccwpck_require__(79925); module.exports = XMLRaw = (function(superClass) { extend(XMLRaw, superClass); @@ -114700,7 +119824,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 57590: +/***/ 63731: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -114709,11 +119833,11 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLWriterBase = __nccwpck_require__(14992); + XMLWriterBase = __nccwpck_require__(46771); - WriterState = __nccwpck_require__(90168); + WriterState = __nccwpck_require__(78358); module.exports = XMLStreamWriter = (function(superClass) { extend(XMLStreamWriter, superClass); @@ -114883,7 +120007,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 91157: +/***/ 99182: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -114892,7 +120016,7 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - XMLWriterBase = __nccwpck_require__(14992); + XMLWriterBase = __nccwpck_require__(46771); module.exports = XMLStringWriter = (function(superClass) { extend(XMLStringWriter, superClass); @@ -114925,7 +120049,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 93841: +/***/ 37188: /***/ (function(module) { // Generated by CoffeeScript 1.12.7 @@ -115172,7 +120296,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 43611: +/***/ 5476: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -115181,9 +120305,9 @@ function wrappy (fn, cb) { extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, hasProp = {}.hasOwnProperty; - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLCharacterData = __nccwpck_require__(16453); + XMLCharacterData = __nccwpck_require__(86306); module.exports = XMLText = (function(superClass) { extend(XMLText, superClass); @@ -115248,7 +120372,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 14992: +/***/ 46771: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 @@ -115256,37 +120380,37 @@ function wrappy (fn, cb) { var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign, hasProp = {}.hasOwnProperty; - assign = (__nccwpck_require__(49049).assign); + assign = (__nccwpck_require__(57205).assign); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - XMLDeclaration = __nccwpck_require__(99037); + XMLDeclaration = __nccwpck_require__(89921); - XMLDocType = __nccwpck_require__(48815); + XMLDocType = __nccwpck_require__(30083); - XMLCData = __nccwpck_require__(44695); + XMLCData = __nccwpck_require__(80929); - XMLComment = __nccwpck_require__(86312); + XMLComment = __nccwpck_require__(32488); - XMLElement = __nccwpck_require__(91825); + XMLElement = __nccwpck_require__(12378); - XMLRaw = __nccwpck_require__(33923); + XMLRaw = __nccwpck_require__(13605); - XMLText = __nccwpck_require__(43611); + XMLText = __nccwpck_require__(5476); - XMLProcessingInstruction = __nccwpck_require__(91219); + XMLProcessingInstruction = __nccwpck_require__(66778); - XMLDummy = __nccwpck_require__(85043); + XMLDummy = __nccwpck_require__(69718); - XMLDTDAttList = __nccwpck_require__(69535); + XMLDTDAttList = __nccwpck_require__(10831); - XMLDTDElement = __nccwpck_require__(97648); + XMLDTDElement = __nccwpck_require__(10058); - XMLDTDEntity = __nccwpck_require__(85257); + XMLDTDEntity = __nccwpck_require__(57827); - XMLDTDNotation = __nccwpck_require__(2604); + XMLDTDNotation = __nccwpck_require__(25985); - WriterState = __nccwpck_require__(90168); + WriterState = __nccwpck_require__(78358); module.exports = XMLWriterBase = (function() { function XMLWriterBase(options) { @@ -115683,28 +120807,28 @@ function wrappy (fn, cb) { /***/ }), -/***/ 84537: +/***/ 16850: /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { // Generated by CoffeeScript 1.12.7 (function() { var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref; - ref = __nccwpck_require__(49049), assign = ref.assign, isFunction = ref.isFunction; + ref = __nccwpck_require__(57205), assign = ref.assign, isFunction = ref.isFunction; - XMLDOMImplementation = __nccwpck_require__(98926); + XMLDOMImplementation = __nccwpck_require__(76267); - XMLDocument = __nccwpck_require__(19258); + XMLDocument = __nccwpck_require__(64); - XMLDocumentCB = __nccwpck_require__(36237); + XMLDocumentCB = __nccwpck_require__(34830); - XMLStringWriter = __nccwpck_require__(91157); + XMLStringWriter = __nccwpck_require__(99182); - XMLStreamWriter = __nccwpck_require__(57590); + XMLStreamWriter = __nccwpck_require__(63731); - NodeType = __nccwpck_require__(93480); + NodeType = __nccwpck_require__(21360); - WriterState = __nccwpck_require__(90168); + WriterState = __nccwpck_require__(78358); module.exports.create = function(name, xmldec, doctype, options) { var doc, root; @@ -115755,7 +120879,7 @@ function wrappy (fn, cb) { /***/ }), -/***/ 79293: +/***/ 53712: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /** @@ -115767,10 +120891,10 @@ function wrappy (fn, cb) { */ var inherits = (__nccwpck_require__(73837).inherits); -var ZipArchiveOutputStream = (__nccwpck_require__(21563).ZipArchiveOutputStream); -var ZipArchiveEntry = (__nccwpck_require__(21563).ZipArchiveEntry); +var ZipArchiveOutputStream = (__nccwpck_require__(28661).ZipArchiveOutputStream); +var ZipArchiveEntry = (__nccwpck_require__(28661).ZipArchiveEntry); -var util = __nccwpck_require__(9925); +var util = __nccwpck_require__(80017); /** * @constructor @@ -115947,5130 +121071,6 @@ ZipStream.prototype.finalize = function() { */ -/***/ }), - -/***/ 87351: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.issue = exports.issueCommand = void 0; -const os = __importStar(__nccwpck_require__(22037)); -const utils_1 = __nccwpck_require__(5278); -/** - * Commands - * - * Command Format: - * ::name key=value,key=value::message - * - * Examples: - * ::warning::This is the message - * ::set-env name=MY_VAR::some value - */ -function issueCommand(command, properties, message) { - const cmd = new Command(command, properties, message); - process.stdout.write(cmd.toString() + os.EOL); -} -exports.issueCommand = issueCommand; -function issue(name, message = '') { - issueCommand(name, {}, message); -} -exports.issue = issue; -const CMD_STRING = '::'; -class Command { - constructor(command, properties, message) { - if (!command) { - command = 'missing.command'; - } - this.command = command; - this.properties = properties; - this.message = message; - } - toString() { - let cmdStr = CMD_STRING + this.command; - if (this.properties && Object.keys(this.properties).length > 0) { - cmdStr += ' '; - let first = true; - for (const key in this.properties) { - if (this.properties.hasOwnProperty(key)) { - const val = this.properties[key]; - if (val) { - if (first) { - first = false; - } - else { - cmdStr += ','; - } - cmdStr += `${key}=${escapeProperty(val)}`; - } - } - } - } - cmdStr += `${CMD_STRING}${escapeData(this.message)}`; - return cmdStr; - } -} -function escapeData(s) { - return utils_1.toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A'); -} -function escapeProperty(s) { - return utils_1.toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A') - .replace(/:/g, '%3A') - .replace(/,/g, '%2C'); -} -//# sourceMappingURL=command.js.map - -/***/ }), - -/***/ 42186: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; -const command_1 = __nccwpck_require__(87351); -const file_command_1 = __nccwpck_require__(717); -const utils_1 = __nccwpck_require__(5278); -const os = __importStar(__nccwpck_require__(22037)); -const path = __importStar(__nccwpck_require__(71017)); -const oidc_utils_1 = __nccwpck_require__(98041); -/** - * The code to exit an action - */ -var ExitCode; -(function (ExitCode) { - /** - * A code indicating that the action was successful - */ - ExitCode[ExitCode["Success"] = 0] = "Success"; - /** - * A code indicating that the action was a failure - */ - ExitCode[ExitCode["Failure"] = 1] = "Failure"; -})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); -//----------------------------------------------------------------------- -// Variables -//----------------------------------------------------------------------- -/** - * Sets env variable for this action and future actions in the job - * @param name the name of the variable to set - * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function exportVariable(name, val) { - const convertedVal = utils_1.toCommandValue(val); - process.env[name] = convertedVal; - const filePath = process.env['GITHUB_ENV'] || ''; - if (filePath) { - return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); - } - command_1.issueCommand('set-env', { name }, convertedVal); -} -exports.exportVariable = exportVariable; -/** - * Registers a secret which will get masked from logs - * @param secret value of the secret - */ -function setSecret(secret) { - command_1.issueCommand('add-mask', {}, secret); -} -exports.setSecret = setSecret; -/** - * Prepends inputPath to the PATH (for this action and future actions) - * @param inputPath - */ -function addPath(inputPath) { - const filePath = process.env['GITHUB_PATH'] || ''; - if (filePath) { - file_command_1.issueFileCommand('PATH', inputPath); - } - else { - command_1.issueCommand('add-path', {}, inputPath); - } - process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; -} -exports.addPath = addPath; -/** - * Gets the value of an input. - * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. - * Returns an empty string if the value is not defined. - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns string - */ -function getInput(name, options) { - const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; - if (options && options.required && !val) { - throw new Error(`Input required and not supplied: ${name}`); - } - if (options && options.trimWhitespace === false) { - return val; - } - return val.trim(); -} -exports.getInput = getInput; -/** - * Gets the values of an multiline input. Each value is also trimmed. - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns string[] - * - */ -function getMultilineInput(name, options) { - const inputs = getInput(name, options) - .split('\n') - .filter(x => x !== ''); - if (options && options.trimWhitespace === false) { - return inputs; - } - return inputs.map(input => input.trim()); -} -exports.getMultilineInput = getMultilineInput; -/** - * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. - * Support boolean input list: `true | True | TRUE | false | False | FALSE` . - * The return value is also in boolean type. - * ref: https://yaml.org/spec/1.2/spec.html#id2804923 - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns boolean - */ -function getBooleanInput(name, options) { - const trueValue = ['true', 'True', 'TRUE']; - const falseValue = ['false', 'False', 'FALSE']; - const val = getInput(name, options); - if (trueValue.includes(val)) - return true; - if (falseValue.includes(val)) - return false; - throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + - `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); -} -exports.getBooleanInput = getBooleanInput; -/** - * Sets the value of an output. - * - * @param name name of the output to set - * @param value value to store. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function setOutput(name, value) { - const filePath = process.env['GITHUB_OUTPUT'] || ''; - if (filePath) { - return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value)); - } - process.stdout.write(os.EOL); - command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); -} -exports.setOutput = setOutput; -/** - * Enables or disables the echoing of commands into stdout for the rest of the step. - * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. - * - */ -function setCommandEcho(enabled) { - command_1.issue('echo', enabled ? 'on' : 'off'); -} -exports.setCommandEcho = setCommandEcho; -//----------------------------------------------------------------------- -// Results -//----------------------------------------------------------------------- -/** - * Sets the action status to failed. - * When the action exits it will be with an exit code of 1 - * @param message add error issue message - */ -function setFailed(message) { - process.exitCode = ExitCode.Failure; - error(message); -} -exports.setFailed = setFailed; -//----------------------------------------------------------------------- -// Logging Commands -//----------------------------------------------------------------------- -/** - * Gets whether Actions Step Debug is on or not - */ -function isDebug() { - return process.env['RUNNER_DEBUG'] === '1'; -} -exports.isDebug = isDebug; -/** - * Writes debug message to user log - * @param message debug message - */ -function debug(message) { - command_1.issueCommand('debug', {}, message); -} -exports.debug = debug; -/** - * Adds an error issue - * @param message error issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function error(message, properties = {}) { - command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); -} -exports.error = error; -/** - * Adds a warning issue - * @param message warning issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function warning(message, properties = {}) { - command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); -} -exports.warning = warning; -/** - * Adds a notice issue - * @param message notice issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function notice(message, properties = {}) { - command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); -} -exports.notice = notice; -/** - * Writes info to log with console.log. - * @param message info message - */ -function info(message) { - process.stdout.write(message + os.EOL); -} -exports.info = info; -/** - * Begin an output group. - * - * Output until the next `groupEnd` will be foldable in this group - * - * @param name The name of the output group - */ -function startGroup(name) { - command_1.issue('group', name); -} -exports.startGroup = startGroup; -/** - * End an output group. - */ -function endGroup() { - command_1.issue('endgroup'); -} -exports.endGroup = endGroup; -/** - * Wrap an asynchronous function call in a group. - * - * Returns the same type as the function itself. - * - * @param name The name of the group - * @param fn The function to wrap in the group - */ -function group(name, fn) { - return __awaiter(this, void 0, void 0, function* () { - startGroup(name); - let result; - try { - result = yield fn(); - } - finally { - endGroup(); - } - return result; - }); -} -exports.group = group; -//----------------------------------------------------------------------- -// Wrapper action state -//----------------------------------------------------------------------- -/** - * Saves state for current action, the state can only be retrieved by this action's post job execution. - * - * @param name name of the state to store - * @param value value to store. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function saveState(name, value) { - const filePath = process.env['GITHUB_STATE'] || ''; - if (filePath) { - return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value)); - } - command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value)); -} -exports.saveState = saveState; -/** - * Gets the value of an state set by this action's main execution. - * - * @param name name of the state to get - * @returns string - */ -function getState(name) { - return process.env[`STATE_${name}`] || ''; -} -exports.getState = getState; -function getIDToken(aud) { - return __awaiter(this, void 0, void 0, function* () { - return yield oidc_utils_1.OidcClient.getIDToken(aud); - }); -} -exports.getIDToken = getIDToken; -/** - * Summary exports - */ -var summary_1 = __nccwpck_require__(81327); -Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); -/** - * @deprecated use core.summary - */ -var summary_2 = __nccwpck_require__(81327); -Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); -/** - * Path exports - */ -var path_utils_1 = __nccwpck_require__(2981); -Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); -Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); -Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); -//# sourceMappingURL=core.js.map - -/***/ }), - -/***/ 717: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -// For internal use, subject to change. -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; -// We use any as a valid input type -/* eslint-disable @typescript-eslint/no-explicit-any */ -const fs = __importStar(__nccwpck_require__(57147)); -const os = __importStar(__nccwpck_require__(22037)); -const uuid_1 = __nccwpck_require__(75840); -const utils_1 = __nccwpck_require__(5278); -function issueFileCommand(command, message) { - const filePath = process.env[`GITHUB_${command}`]; - if (!filePath) { - throw new Error(`Unable to find environment variable for file command ${command}`); - } - if (!fs.existsSync(filePath)) { - throw new Error(`Missing file at path: ${filePath}`); - } - fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { - encoding: 'utf8' - }); -} -exports.issueFileCommand = issueFileCommand; -function prepareKeyValueMessage(key, value) { - const delimiter = `ghadelimiter_${uuid_1.v4()}`; - const convertedValue = utils_1.toCommandValue(value); - // These should realistically never happen, but just in case someone finds a - // way to exploit uuid generation let's not allow keys or values that contain - // the delimiter. - if (key.includes(delimiter)) { - throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); - } - if (convertedValue.includes(delimiter)) { - throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); - } - return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; -} -exports.prepareKeyValueMessage = prepareKeyValueMessage; -//# sourceMappingURL=file-command.js.map - -/***/ }), - -/***/ 98041: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.OidcClient = void 0; -const http_client_1 = __nccwpck_require__(96255); -const auth_1 = __nccwpck_require__(35526); -const core_1 = __nccwpck_require__(42186); -class OidcClient { - static createHttpClient(allowRetry = true, maxRetry = 10) { - const requestOptions = { - allowRetries: allowRetry, - maxRetries: maxRetry - }; - return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); - } - static getRequestToken() { - const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; - if (!token) { - throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); - } - return token; - } - static getIDTokenUrl() { - const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; - if (!runtimeUrl) { - throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); - } - return runtimeUrl; - } - static getCall(id_token_url) { - var _a; - return __awaiter(this, void 0, void 0, function* () { - const httpclient = OidcClient.createHttpClient(); - const res = yield httpclient - .getJson(id_token_url) - .catch(error => { - throw new Error(`Failed to get ID Token. \n - Error Code : ${error.statusCode}\n - Error Message: ${error.result.message}`); - }); - const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; - if (!id_token) { - throw new Error('Response json body do not have ID Token field'); - } - return id_token; - }); - } - static getIDToken(audience) { - return __awaiter(this, void 0, void 0, function* () { - try { - // New ID Token is requested from action service - let id_token_url = OidcClient.getIDTokenUrl(); - if (audience) { - const encodedAudience = encodeURIComponent(audience); - id_token_url = `${id_token_url}&audience=${encodedAudience}`; - } - core_1.debug(`ID token url is ${id_token_url}`); - const id_token = yield OidcClient.getCall(id_token_url); - core_1.setSecret(id_token); - return id_token; - } - catch (error) { - throw new Error(`Error message: ${error.message}`); - } - }); - } -} -exports.OidcClient = OidcClient; -//# sourceMappingURL=oidc-utils.js.map - -/***/ }), - -/***/ 2981: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = void 0; -const path = __importStar(__nccwpck_require__(71017)); -/** - * toPosixPath converts the given path to the posix form. On Windows, \\ will be - * replaced with /. - * - * @param pth. Path to transform. - * @return string Posix path. - */ -function toPosixPath(pth) { - return pth.replace(/[\\]/g, '/'); -} -exports.toPosixPath = toPosixPath; -/** - * toWin32Path converts the given path to the win32 form. On Linux, / will be - * replaced with \\. - * - * @param pth. Path to transform. - * @return string Win32 path. - */ -function toWin32Path(pth) { - return pth.replace(/[/]/g, '\\'); -} -exports.toWin32Path = toWin32Path; -/** - * toPlatformPath converts the given path to a platform-specific path. It does - * this by replacing instances of / and \ with the platform-specific path - * separator. - * - * @param pth The path to platformize. - * @return string The platform-specific path. - */ -function toPlatformPath(pth) { - return pth.replace(/[/\\]/g, path.sep); -} -exports.toPlatformPath = toPlatformPath; -//# sourceMappingURL=path-utils.js.map - -/***/ }), - -/***/ 81327: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0; -const os_1 = __nccwpck_require__(22037); -const fs_1 = __nccwpck_require__(57147); -const { access, appendFile, writeFile } = fs_1.promises; -exports.SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY'; -exports.SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary'; -class Summary { - constructor() { - this._buffer = ''; - } - /** - * Finds the summary file path from the environment, rejects if env var is not found or file does not exist - * Also checks r/w permissions. - * - * @returns step summary file path - */ - filePath() { - return __awaiter(this, void 0, void 0, function* () { - if (this._filePath) { - return this._filePath; - } - const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR]; - if (!pathFromEnv) { - throw new Error(`Unable to find environment variable for $${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); - } - try { - yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); - } - catch (_a) { - throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); - } - this._filePath = pathFromEnv; - return this._filePath; - }); - } - /** - * Wraps content in an HTML tag, adding any HTML attributes - * - * @param {string} tag HTML tag to wrap - * @param {string | null} content content within the tag - * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add - * - * @returns {string} content wrapped in HTML element - */ - wrap(tag, content, attrs = {}) { - const htmlAttrs = Object.entries(attrs) - .map(([key, value]) => ` ${key}="${value}"`) - .join(''); - if (!content) { - return `<${tag}${htmlAttrs}>`; - } - return `<${tag}${htmlAttrs}>${content}`; - } - /** - * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. - * - * @param {SummaryWriteOptions} [options] (optional) options for write operation - * - * @returns {Promise} summary instance - */ - write(options) { - return __awaiter(this, void 0, void 0, function* () { - const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); - const filePath = yield this.filePath(); - const writeFunc = overwrite ? writeFile : appendFile; - yield writeFunc(filePath, this._buffer, { encoding: 'utf8' }); - return this.emptyBuffer(); - }); - } - /** - * Clears the summary buffer and wipes the summary file - * - * @returns {Summary} summary instance - */ - clear() { - return __awaiter(this, void 0, void 0, function* () { - return this.emptyBuffer().write({ overwrite: true }); - }); - } - /** - * Returns the current summary buffer as a string - * - * @returns {string} string of summary buffer - */ - stringify() { - return this._buffer; - } - /** - * If the summary buffer is empty - * - * @returns {boolen} true if the buffer is empty - */ - isEmptyBuffer() { - return this._buffer.length === 0; - } - /** - * Resets the summary buffer without writing to summary file - * - * @returns {Summary} summary instance - */ - emptyBuffer() { - this._buffer = ''; - return this; - } - /** - * Adds raw text to the summary buffer - * - * @param {string} text content to add - * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) - * - * @returns {Summary} summary instance - */ - addRaw(text, addEOL = false) { - this._buffer += text; - return addEOL ? this.addEOL() : this; - } - /** - * Adds the operating system-specific end-of-line marker to the buffer - * - * @returns {Summary} summary instance - */ - addEOL() { - return this.addRaw(os_1.EOL); - } - /** - * Adds an HTML codeblock to the summary buffer - * - * @param {string} code content to render within fenced code block - * @param {string} lang (optional) language to syntax highlight code - * - * @returns {Summary} summary instance - */ - addCodeBlock(code, lang) { - const attrs = Object.assign({}, (lang && { lang })); - const element = this.wrap('pre', this.wrap('code', code), attrs); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML list to the summary buffer - * - * @param {string[]} items list of items to render - * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) - * - * @returns {Summary} summary instance - */ - addList(items, ordered = false) { - const tag = ordered ? 'ol' : 'ul'; - const listItems = items.map(item => this.wrap('li', item)).join(''); - const element = this.wrap(tag, listItems); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML table to the summary buffer - * - * @param {SummaryTableCell[]} rows table rows - * - * @returns {Summary} summary instance - */ - addTable(rows) { - const tableBody = rows - .map(row => { - const cells = row - .map(cell => { - if (typeof cell === 'string') { - return this.wrap('td', cell); - } - const { header, data, colspan, rowspan } = cell; - const tag = header ? 'th' : 'td'; - const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan })); - return this.wrap(tag, data, attrs); - }) - .join(''); - return this.wrap('tr', cells); - }) - .join(''); - const element = this.wrap('table', tableBody); - return this.addRaw(element).addEOL(); - } - /** - * Adds a collapsable HTML details element to the summary buffer - * - * @param {string} label text for the closed state - * @param {string} content collapsable content - * - * @returns {Summary} summary instance - */ - addDetails(label, content) { - const element = this.wrap('details', this.wrap('summary', label) + content); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML image tag to the summary buffer - * - * @param {string} src path to the image you to embed - * @param {string} alt text description of the image - * @param {SummaryImageOptions} options (optional) addition image attributes - * - * @returns {Summary} summary instance - */ - addImage(src, alt, options) { - const { width, height } = options || {}; - const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height })); - const element = this.wrap('img', null, Object.assign({ src, alt }, attrs)); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML section heading element - * - * @param {string} text heading text - * @param {number | string} [level=1] (optional) the heading level, default: 1 - * - * @returns {Summary} summary instance - */ - addHeading(text, level) { - const tag = `h${level}`; - const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag) - ? tag - : 'h1'; - const element = this.wrap(allowedTag, text); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML thematic break (
) to the summary buffer - * - * @returns {Summary} summary instance - */ - addSeparator() { - const element = this.wrap('hr', null); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML line break (
) to the summary buffer - * - * @returns {Summary} summary instance - */ - addBreak() { - const element = this.wrap('br', null); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML blockquote to the summary buffer - * - * @param {string} text quote text - * @param {string} cite (optional) citation url - * - * @returns {Summary} summary instance - */ - addQuote(text, cite) { - const attrs = Object.assign({}, (cite && { cite })); - const element = this.wrap('blockquote', text, attrs); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML anchor tag to the summary buffer - * - * @param {string} text link text/content - * @param {string} href hyperlink - * - * @returns {Summary} summary instance - */ - addLink(text, href) { - const element = this.wrap('a', text, { href }); - return this.addRaw(element).addEOL(); - } -} -const _summary = new Summary(); -/** - * @deprecated use `core.summary` - */ -exports.markdownSummary = _summary; -exports.summary = _summary; -//# sourceMappingURL=summary.js.map - -/***/ }), - -/***/ 5278: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// We use any as a valid input type -/* eslint-disable @typescript-eslint/no-explicit-any */ -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.toCommandProperties = exports.toCommandValue = void 0; -/** - * Sanitizes an input into a string so it can be passed into issueCommand safely - * @param input input to sanitize into a string - */ -function toCommandValue(input) { - if (input === null || input === undefined) { - return ''; - } - else if (typeof input === 'string' || input instanceof String) { - return input; - } - return JSON.stringify(input); -} -exports.toCommandValue = toCommandValue; -/** - * - * @param annotationProperties - * @returns The command properties to send with the actual annotation command - * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 - */ -function toCommandProperties(annotationProperties) { - if (!Object.keys(annotationProperties).length) { - return {}; - } - return { - title: annotationProperties.title, - file: annotationProperties.file, - line: annotationProperties.startLine, - endLine: annotationProperties.endLine, - col: annotationProperties.startColumn, - endColumn: annotationProperties.endColumn - }; -} -exports.toCommandProperties = toCommandProperties; -//# sourceMappingURL=utils.js.map - -/***/ }), - -/***/ 28090: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.hashFiles = exports.create = void 0; -const internal_globber_1 = __nccwpck_require__(28298); -const internal_hash_files_1 = __nccwpck_require__(2448); -/** - * Constructs a globber - * - * @param patterns Patterns separated by newlines - * @param options Glob options - */ -function create(patterns, options) { - return __awaiter(this, void 0, void 0, function* () { - return yield internal_globber_1.DefaultGlobber.create(patterns, options); - }); -} -exports.create = create; -/** - * Computes the sha256 hash of a glob - * - * @param patterns Patterns separated by newlines - * @param options Glob options - */ -function hashFiles(patterns, options, verbose = false) { - return __awaiter(this, void 0, void 0, function* () { - let followSymbolicLinks = true; - if (options && typeof options.followSymbolicLinks === 'boolean') { - followSymbolicLinks = options.followSymbolicLinks; - } - const globber = yield create(patterns, { followSymbolicLinks }); - return internal_hash_files_1.hashFiles(globber, verbose); - }); -} -exports.hashFiles = hashFiles; -//# sourceMappingURL=glob.js.map - -/***/ }), - -/***/ 51026: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOptions = void 0; -const core = __importStar(__nccwpck_require__(42186)); -/** - * Returns a copy with defaults filled in. - */ -function getOptions(copy) { - const result = { - followSymbolicLinks: true, - implicitDescendants: true, - matchDirectories: true, - omitBrokenSymbolicLinks: true - }; - if (copy) { - if (typeof copy.followSymbolicLinks === 'boolean') { - result.followSymbolicLinks = copy.followSymbolicLinks; - core.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`); - } - if (typeof copy.implicitDescendants === 'boolean') { - result.implicitDescendants = copy.implicitDescendants; - core.debug(`implicitDescendants '${result.implicitDescendants}'`); - } - if (typeof copy.matchDirectories === 'boolean') { - result.matchDirectories = copy.matchDirectories; - core.debug(`matchDirectories '${result.matchDirectories}'`); - } - if (typeof copy.omitBrokenSymbolicLinks === 'boolean') { - result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks; - core.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`); - } - } - return result; -} -exports.getOptions = getOptions; -//# sourceMappingURL=internal-glob-options-helper.js.map - -/***/ }), - -/***/ 28298: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __asyncValues = (this && this.__asyncValues) || function (o) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var m = o[Symbol.asyncIterator], i; - return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); - function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } - function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } -}; -var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } -var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var g = generator.apply(thisArg, _arguments || []), i, q = []; - return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; - function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } - function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } - function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } - function fulfill(value) { resume("next", value); } - function reject(value) { resume("throw", value); } - function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.DefaultGlobber = void 0; -const core = __importStar(__nccwpck_require__(42186)); -const fs = __importStar(__nccwpck_require__(57147)); -const globOptionsHelper = __importStar(__nccwpck_require__(51026)); -const path = __importStar(__nccwpck_require__(71017)); -const patternHelper = __importStar(__nccwpck_require__(29005)); -const internal_match_kind_1 = __nccwpck_require__(81063); -const internal_pattern_1 = __nccwpck_require__(64536); -const internal_search_state_1 = __nccwpck_require__(89117); -const IS_WINDOWS = process.platform === 'win32'; -class DefaultGlobber { - constructor(options) { - this.patterns = []; - this.searchPaths = []; - this.options = globOptionsHelper.getOptions(options); - } - getSearchPaths() { - // Return a copy - return this.searchPaths.slice(); - } - glob() { - var e_1, _a; - return __awaiter(this, void 0, void 0, function* () { - const result = []; - try { - for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) { - const itemPath = _c.value; - result.push(itemPath); - } - } - catch (e_1_1) { e_1 = { error: e_1_1 }; } - finally { - try { - if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b); - } - finally { if (e_1) throw e_1.error; } - } - return result; - }); - } - globGenerator() { - return __asyncGenerator(this, arguments, function* globGenerator_1() { - // Fill in defaults options - const options = globOptionsHelper.getOptions(this.options); - // Implicit descendants? - const patterns = []; - for (const pattern of this.patterns) { - patterns.push(pattern); - if (options.implicitDescendants && - (pattern.trailingSeparator || - pattern.segments[pattern.segments.length - 1] !== '**')) { - patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**'))); - } - } - // Push the search paths - const stack = []; - for (const searchPath of patternHelper.getSearchPaths(patterns)) { - core.debug(`Search path '${searchPath}'`); - // Exists? - try { - // Intentionally using lstat. Detection for broken symlink - // will be performed later (if following symlinks). - yield __await(fs.promises.lstat(searchPath)); - } - catch (err) { - if (err.code === 'ENOENT') { - continue; - } - throw err; - } - stack.unshift(new internal_search_state_1.SearchState(searchPath, 1)); - } - // Search - const traversalChain = []; // used to detect cycles - while (stack.length) { - // Pop - const item = stack.pop(); - // Match? - const match = patternHelper.match(patterns, item.path); - const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path); - if (!match && !partialMatch) { - continue; - } - // Stat - const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain) - // Broken symlink, or symlink cycle detected, or no longer exists - ); - // Broken symlink, or symlink cycle detected, or no longer exists - if (!stats) { - continue; - } - // Directory - if (stats.isDirectory()) { - // Matched - if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) { - yield yield __await(item.path); - } - // Descend? - else if (!partialMatch) { - continue; - } - // Push the child items in reverse - const childLevel = item.level + 1; - const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel)); - stack.push(...childItems.reverse()); - } - // File - else if (match & internal_match_kind_1.MatchKind.File) { - yield yield __await(item.path); - } - } - }); - } - /** - * Constructs a DefaultGlobber - */ - static create(patterns, options) { - return __awaiter(this, void 0, void 0, function* () { - const result = new DefaultGlobber(options); - if (IS_WINDOWS) { - patterns = patterns.replace(/\r\n/g, '\n'); - patterns = patterns.replace(/\r/g, '\n'); - } - const lines = patterns.split('\n').map(x => x.trim()); - for (const line of lines) { - // Empty or comment - if (!line || line.startsWith('#')) { - continue; - } - // Pattern - else { - result.patterns.push(new internal_pattern_1.Pattern(line)); - } - } - result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns)); - return result; - }); - } - static stat(item, options, traversalChain) { - return __awaiter(this, void 0, void 0, function* () { - // Note: - // `stat` returns info about the target of a symlink (or symlink chain) - // `lstat` returns info about a symlink itself - let stats; - if (options.followSymbolicLinks) { - try { - // Use `stat` (following symlinks) - stats = yield fs.promises.stat(item.path); - } - catch (err) { - if (err.code === 'ENOENT') { - if (options.omitBrokenSymbolicLinks) { - core.debug(`Broken symlink '${item.path}'`); - return undefined; - } - throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`); - } - throw err; - } - } - else { - // Use `lstat` (not following symlinks) - stats = yield fs.promises.lstat(item.path); - } - // Note, isDirectory() returns false for the lstat of a symlink - if (stats.isDirectory() && options.followSymbolicLinks) { - // Get the realpath - const realPath = yield fs.promises.realpath(item.path); - // Fixup the traversal chain to match the item level - while (traversalChain.length >= item.level) { - traversalChain.pop(); - } - // Test for a cycle - if (traversalChain.some((x) => x === realPath)) { - core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`); - return undefined; - } - // Update the traversal chain - traversalChain.push(realPath); - } - return stats; - }); - } -} -exports.DefaultGlobber = DefaultGlobber; -//# sourceMappingURL=internal-globber.js.map - -/***/ }), - -/***/ 2448: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var __asyncValues = (this && this.__asyncValues) || function (o) { - if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); - var m = o[Symbol.asyncIterator], i; - return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); - function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } - function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.hashFiles = void 0; -const crypto = __importStar(__nccwpck_require__(6113)); -const core = __importStar(__nccwpck_require__(42186)); -const fs = __importStar(__nccwpck_require__(57147)); -const stream = __importStar(__nccwpck_require__(12781)); -const util = __importStar(__nccwpck_require__(73837)); -const path = __importStar(__nccwpck_require__(71017)); -function hashFiles(globber, verbose = false) { - var e_1, _a; - var _b; - return __awaiter(this, void 0, void 0, function* () { - const writeDelegate = verbose ? core.info : core.debug; - let hasMatch = false; - const githubWorkspace = (_b = process.env['GITHUB_WORKSPACE']) !== null && _b !== void 0 ? _b : process.cwd(); - const result = crypto.createHash('sha256'); - let count = 0; - try { - for (var _c = __asyncValues(globber.globGenerator()), _d; _d = yield _c.next(), !_d.done;) { - const file = _d.value; - writeDelegate(file); - if (!file.startsWith(`${githubWorkspace}${path.sep}`)) { - writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`); - continue; - } - if (fs.statSync(file).isDirectory()) { - writeDelegate(`Skip directory '${file}'.`); - continue; - } - const hash = crypto.createHash('sha256'); - const pipeline = util.promisify(stream.pipeline); - yield pipeline(fs.createReadStream(file), hash); - result.write(hash.digest()); - count++; - if (!hasMatch) { - hasMatch = true; - } - } - } - catch (e_1_1) { e_1 = { error: e_1_1 }; } - finally { - try { - if (_d && !_d.done && (_a = _c.return)) yield _a.call(_c); - } - finally { if (e_1) throw e_1.error; } - } - result.end(); - if (hasMatch) { - writeDelegate(`Found ${count} files to hash.`); - return result.digest('hex'); - } - else { - writeDelegate(`No matches found for glob`); - return ''; - } - }); -} -exports.hashFiles = hashFiles; -//# sourceMappingURL=internal-hash-files.js.map - -/***/ }), - -/***/ 81063: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.MatchKind = void 0; -/** - * Indicates whether a pattern matches a path - */ -var MatchKind; -(function (MatchKind) { - /** Not matched */ - MatchKind[MatchKind["None"] = 0] = "None"; - /** Matched if the path is a directory */ - MatchKind[MatchKind["Directory"] = 1] = "Directory"; - /** Matched if the path is a regular file */ - MatchKind[MatchKind["File"] = 2] = "File"; - /** Matched */ - MatchKind[MatchKind["All"] = 3] = "All"; -})(MatchKind = exports.MatchKind || (exports.MatchKind = {})); -//# sourceMappingURL=internal-match-kind.js.map - -/***/ }), - -/***/ 1849: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __importDefault = (this && this.__importDefault) || function (mod) { - return (mod && mod.__esModule) ? mod : { "default": mod }; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = void 0; -const path = __importStar(__nccwpck_require__(71017)); -const assert_1 = __importDefault(__nccwpck_require__(39491)); -const IS_WINDOWS = process.platform === 'win32'; -/** - * Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths. - * - * For example, on Linux/macOS: - * - `/ => /` - * - `/hello => /` - * - * For example, on Windows: - * - `C:\ => C:\` - * - `C:\hello => C:\` - * - `C: => C:` - * - `C:hello => C:` - * - `\ => \` - * - `\hello => \` - * - `\\hello => \\hello` - * - `\\hello\world => \\hello\world` - */ -function dirname(p) { - // Normalize slashes and trim unnecessary trailing slash - p = safeTrimTrailingSeparator(p); - // Windows UNC root, e.g. \\hello or \\hello\world - if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { - return p; - } - // Get dirname - let result = path.dirname(p); - // Trim trailing slash for Windows UNC root, e.g. \\hello\world\ - if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { - result = safeTrimTrailingSeparator(result); - } - return result; -} -exports.dirname = dirname; -/** - * Roots the path if not already rooted. On Windows, relative roots like `\` - * or `C:` are expanded based on the current working directory. - */ -function ensureAbsoluteRoot(root, itemPath) { - assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`); - assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`); - // Already rooted - if (hasAbsoluteRoot(itemPath)) { - return itemPath; - } - // Windows - if (IS_WINDOWS) { - // Check for itemPath like C: or C:foo - if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) { - let cwd = process.cwd(); - assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); - // Drive letter matches cwd? Expand to cwd - if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) { - // Drive only, e.g. C: - if (itemPath.length === 2) { - // Preserve specified drive letter case (upper or lower) - return `${itemPath[0]}:\\${cwd.substr(3)}`; - } - // Drive + path, e.g. C:foo - else { - if (!cwd.endsWith('\\')) { - cwd += '\\'; - } - // Preserve specified drive letter case (upper or lower) - return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`; - } - } - // Different drive - else { - return `${itemPath[0]}:\\${itemPath.substr(2)}`; - } - } - // Check for itemPath like \ or \foo - else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) { - const cwd = process.cwd(); - assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); - return `${cwd[0]}:\\${itemPath.substr(1)}`; - } - } - assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`); - // Otherwise ensure root ends with a separator - if (root.endsWith('/') || (IS_WINDOWS && root.endsWith('\\'))) { - // Intentionally empty - } - else { - // Append separator - root += path.sep; - } - return root + itemPath; -} -exports.ensureAbsoluteRoot = ensureAbsoluteRoot; -/** - * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: - * `\\hello\share` and `C:\hello` (and using alternate separator). - */ -function hasAbsoluteRoot(itemPath) { - assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`); - // Normalize separators - itemPath = normalizeSeparators(itemPath); - // Windows - if (IS_WINDOWS) { - // E.g. \\hello\share or C:\hello - return itemPath.startsWith('\\\\') || /^[A-Z]:\\/i.test(itemPath); - } - // E.g. /hello - return itemPath.startsWith('/'); -} -exports.hasAbsoluteRoot = hasAbsoluteRoot; -/** - * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: - * `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator). - */ -function hasRoot(itemPath) { - assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`); - // Normalize separators - itemPath = normalizeSeparators(itemPath); - // Windows - if (IS_WINDOWS) { - // E.g. \ or \hello or \\hello - // E.g. C: or C:\hello - return itemPath.startsWith('\\') || /^[A-Z]:/i.test(itemPath); - } - // E.g. /hello - return itemPath.startsWith('/'); -} -exports.hasRoot = hasRoot; -/** - * Removes redundant slashes and converts `/` to `\` on Windows - */ -function normalizeSeparators(p) { - p = p || ''; - // Windows - if (IS_WINDOWS) { - // Convert slashes on Windows - p = p.replace(/\//g, '\\'); - // Remove redundant slashes - const isUnc = /^\\\\+[^\\]/.test(p); // e.g. \\hello - return (isUnc ? '\\' : '') + p.replace(/\\\\+/g, '\\'); // preserve leading \\ for UNC - } - // Remove redundant slashes - return p.replace(/\/\/+/g, '/'); -} -exports.normalizeSeparators = normalizeSeparators; -/** - * Normalizes the path separators and trims the trailing separator (when safe). - * For example, `/foo/ => /foo` but `/ => /` - */ -function safeTrimTrailingSeparator(p) { - // Short-circuit if empty - if (!p) { - return ''; - } - // Normalize separators - p = normalizeSeparators(p); - // No trailing slash - if (!p.endsWith(path.sep)) { - return p; - } - // Check '/' on Linux/macOS and '\' on Windows - if (p === path.sep) { - return p; - } - // On Windows check if drive root. E.g. C:\ - if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) { - return p; - } - // Otherwise trim trailing slash - return p.substr(0, p.length - 1); -} -exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator; -//# sourceMappingURL=internal-path-helper.js.map - -/***/ }), - -/***/ 96836: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __importDefault = (this && this.__importDefault) || function (mod) { - return (mod && mod.__esModule) ? mod : { "default": mod }; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Path = void 0; -const path = __importStar(__nccwpck_require__(71017)); -const pathHelper = __importStar(__nccwpck_require__(1849)); -const assert_1 = __importDefault(__nccwpck_require__(39491)); -const IS_WINDOWS = process.platform === 'win32'; -/** - * Helper class for parsing paths into segments - */ -class Path { - /** - * Constructs a Path - * @param itemPath Path or array of segments - */ - constructor(itemPath) { - this.segments = []; - // String - if (typeof itemPath === 'string') { - assert_1.default(itemPath, `Parameter 'itemPath' must not be empty`); - // Normalize slashes and trim unnecessary trailing slash - itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); - // Not rooted - if (!pathHelper.hasRoot(itemPath)) { - this.segments = itemPath.split(path.sep); - } - // Rooted - else { - // Add all segments, while not at the root - let remaining = itemPath; - let dir = pathHelper.dirname(remaining); - while (dir !== remaining) { - // Add the segment - const basename = path.basename(remaining); - this.segments.unshift(basename); - // Truncate the last segment - remaining = dir; - dir = pathHelper.dirname(remaining); - } - // Remainder is the root - this.segments.unshift(remaining); - } - } - // Array - else { - // Must not be empty - assert_1.default(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`); - // Each segment - for (let i = 0; i < itemPath.length; i++) { - let segment = itemPath[i]; - // Must not be empty - assert_1.default(segment, `Parameter 'itemPath' must not contain any empty segments`); - // Normalize slashes - segment = pathHelper.normalizeSeparators(itemPath[i]); - // Root segment - if (i === 0 && pathHelper.hasRoot(segment)) { - segment = pathHelper.safeTrimTrailingSeparator(segment); - assert_1.default(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`); - this.segments.push(segment); - } - // All other segments - else { - // Must not contain slash - assert_1.default(!segment.includes(path.sep), `Parameter 'itemPath' contains unexpected path separators`); - this.segments.push(segment); - } - } - } - } - /** - * Converts the path to it's string representation - */ - toString() { - // First segment - let result = this.segments[0]; - // All others - let skipSlash = result.endsWith(path.sep) || (IS_WINDOWS && /^[A-Z]:$/i.test(result)); - for (let i = 1; i < this.segments.length; i++) { - if (skipSlash) { - skipSlash = false; - } - else { - result += path.sep; - } - result += this.segments[i]; - } - return result; - } -} -exports.Path = Path; -//# sourceMappingURL=internal-path.js.map - -/***/ }), - -/***/ 29005: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.partialMatch = exports.match = exports.getSearchPaths = void 0; -const pathHelper = __importStar(__nccwpck_require__(1849)); -const internal_match_kind_1 = __nccwpck_require__(81063); -const IS_WINDOWS = process.platform === 'win32'; -/** - * Given an array of patterns, returns an array of paths to search. - * Duplicates and paths under other included paths are filtered out. - */ -function getSearchPaths(patterns) { - // Ignore negate patterns - patterns = patterns.filter(x => !x.negate); - // Create a map of all search paths - const searchPathMap = {}; - for (const pattern of patterns) { - const key = IS_WINDOWS - ? pattern.searchPath.toUpperCase() - : pattern.searchPath; - searchPathMap[key] = 'candidate'; - } - const result = []; - for (const pattern of patterns) { - // Check if already included - const key = IS_WINDOWS - ? pattern.searchPath.toUpperCase() - : pattern.searchPath; - if (searchPathMap[key] === 'included') { - continue; - } - // Check for an ancestor search path - let foundAncestor = false; - let tempKey = key; - let parent = pathHelper.dirname(tempKey); - while (parent !== tempKey) { - if (searchPathMap[parent]) { - foundAncestor = true; - break; - } - tempKey = parent; - parent = pathHelper.dirname(tempKey); - } - // Include the search pattern in the result - if (!foundAncestor) { - result.push(pattern.searchPath); - searchPathMap[key] = 'included'; - } - } - return result; -} -exports.getSearchPaths = getSearchPaths; -/** - * Matches the patterns against the path - */ -function match(patterns, itemPath) { - let result = internal_match_kind_1.MatchKind.None; - for (const pattern of patterns) { - if (pattern.negate) { - result &= ~pattern.match(itemPath); - } - else { - result |= pattern.match(itemPath); - } - } - return result; -} -exports.match = match; -/** - * Checks whether to descend further into the directory - */ -function partialMatch(patterns, itemPath) { - return patterns.some(x => !x.negate && x.partialMatch(itemPath)); -} -exports.partialMatch = partialMatch; -//# sourceMappingURL=internal-pattern-helper.js.map - -/***/ }), - -/***/ 64536: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __importDefault = (this && this.__importDefault) || function (mod) { - return (mod && mod.__esModule) ? mod : { "default": mod }; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Pattern = void 0; -const os = __importStar(__nccwpck_require__(22037)); -const path = __importStar(__nccwpck_require__(71017)); -const pathHelper = __importStar(__nccwpck_require__(1849)); -const assert_1 = __importDefault(__nccwpck_require__(39491)); -const minimatch_1 = __nccwpck_require__(83973); -const internal_match_kind_1 = __nccwpck_require__(81063); -const internal_path_1 = __nccwpck_require__(96836); -const IS_WINDOWS = process.platform === 'win32'; -class Pattern { - constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) { - /** - * Indicates whether matches should be excluded from the result set - */ - this.negate = false; - // Pattern overload - let pattern; - if (typeof patternOrNegate === 'string') { - pattern = patternOrNegate.trim(); - } - // Segments overload - else { - // Convert to pattern - segments = segments || []; - assert_1.default(segments.length, `Parameter 'segments' must not empty`); - const root = Pattern.getLiteral(segments[0]); - assert_1.default(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`); - pattern = new internal_path_1.Path(segments).toString().trim(); - if (patternOrNegate) { - pattern = `!${pattern}`; - } - } - // Negate - while (pattern.startsWith('!')) { - this.negate = !this.negate; - pattern = pattern.substr(1).trim(); - } - // Normalize slashes and ensures absolute root - pattern = Pattern.fixupPattern(pattern, homedir); - // Segments - this.segments = new internal_path_1.Path(pattern).segments; - // Trailing slash indicates the pattern should only match directories, not regular files - this.trailingSeparator = pathHelper - .normalizeSeparators(pattern) - .endsWith(path.sep); - pattern = pathHelper.safeTrimTrailingSeparator(pattern); - // Search path (literal path prior to the first glob segment) - let foundGlob = false; - const searchSegments = this.segments - .map(x => Pattern.getLiteral(x)) - .filter(x => !foundGlob && !(foundGlob = x === '')); - this.searchPath = new internal_path_1.Path(searchSegments).toString(); - // Root RegExp (required when determining partial match) - this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? 'i' : ''); - this.isImplicitPattern = isImplicitPattern; - // Create minimatch - const minimatchOptions = { - dot: true, - nobrace: true, - nocase: IS_WINDOWS, - nocomment: true, - noext: true, - nonegate: true - }; - pattern = IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern; - this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions); - } - /** - * Matches the pattern against the specified path - */ - match(itemPath) { - // Last segment is globstar? - if (this.segments[this.segments.length - 1] === '**') { - // Normalize slashes - itemPath = pathHelper.normalizeSeparators(itemPath); - // Append a trailing slash. Otherwise Minimatch will not match the directory immediately - // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns - // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk. - if (!itemPath.endsWith(path.sep) && this.isImplicitPattern === false) { - // Note, this is safe because the constructor ensures the pattern has an absolute root. - // For example, formats like C: and C:foo on Windows are resolved to an absolute root. - itemPath = `${itemPath}${path.sep}`; - } - } - else { - // Normalize slashes and trim unnecessary trailing slash - itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); - } - // Match - if (this.minimatch.match(itemPath)) { - return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All; - } - return internal_match_kind_1.MatchKind.None; - } - /** - * Indicates whether the pattern may match descendants of the specified path - */ - partialMatch(itemPath) { - // Normalize slashes and trim unnecessary trailing slash - itemPath = pathHelper.safeTrimTrailingSeparator(itemPath); - // matchOne does not handle root path correctly - if (pathHelper.dirname(itemPath) === itemPath) { - return this.rootRegExp.test(itemPath); - } - return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true); - } - /** - * Escapes glob patterns within a path - */ - static globEscape(s) { - return (IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS - .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment - .replace(/\?/g, '[?]') // escape '?' - .replace(/\*/g, '[*]'); // escape '*' - } - /** - * Normalizes slashes and ensures absolute root - */ - static fixupPattern(pattern, homedir) { - // Empty - assert_1.default(pattern, 'pattern cannot be empty'); - // Must not contain `.` segment, unless first segment - // Must not contain `..` segment - const literalSegments = new internal_path_1.Path(pattern).segments.map(x => Pattern.getLiteral(x)); - assert_1.default(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`); - // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r - assert_1.default(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`); - // Normalize slashes - pattern = pathHelper.normalizeSeparators(pattern); - // Replace leading `.` segment - if (pattern === '.' || pattern.startsWith(`.${path.sep}`)) { - pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1); - } - // Replace leading `~` segment - else if (pattern === '~' || pattern.startsWith(`~${path.sep}`)) { - homedir = homedir || os.homedir(); - assert_1.default(homedir, 'Unable to determine HOME directory'); - assert_1.default(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`); - pattern = Pattern.globEscape(homedir) + pattern.substr(1); - } - // Replace relative drive root, e.g. pattern is C: or C:foo - else if (IS_WINDOWS && - (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) { - let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2)); - if (pattern.length > 2 && !root.endsWith('\\')) { - root += '\\'; - } - pattern = Pattern.globEscape(root) + pattern.substr(2); - } - // Replace relative root, e.g. pattern is \ or \foo - else if (IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) { - let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', '\\'); - if (!root.endsWith('\\')) { - root += '\\'; - } - pattern = Pattern.globEscape(root) + pattern.substr(1); - } - // Otherwise ensure absolute root - else { - pattern = pathHelper.ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern); - } - return pathHelper.normalizeSeparators(pattern); - } - /** - * Attempts to unescape a pattern segment to create a literal path segment. - * Otherwise returns empty string. - */ - static getLiteral(segment) { - let literal = ''; - for (let i = 0; i < segment.length; i++) { - const c = segment[i]; - // Escape - if (c === '\\' && !IS_WINDOWS && i + 1 < segment.length) { - literal += segment[++i]; - continue; - } - // Wildcard - else if (c === '*' || c === '?') { - return ''; - } - // Character set - else if (c === '[' && i + 1 < segment.length) { - let set = ''; - let closed = -1; - for (let i2 = i + 1; i2 < segment.length; i2++) { - const c2 = segment[i2]; - // Escape - if (c2 === '\\' && !IS_WINDOWS && i2 + 1 < segment.length) { - set += segment[++i2]; - continue; - } - // Closed - else if (c2 === ']') { - closed = i2; - break; - } - // Otherwise - else { - set += c2; - } - } - // Closed? - if (closed >= 0) { - // Cannot convert - if (set.length > 1) { - return ''; - } - // Convert to literal - if (set) { - literal += set; - i = closed; - continue; - } - } - // Otherwise fall thru - } - // Append - literal += c; - } - return literal; - } - /** - * Escapes regexp special characters - * https://javascript.info/regexp-escaping - */ - static regExpEscape(s) { - return s.replace(/[[\\^$.|?*+()]/g, '\\$&'); - } -} -exports.Pattern = Pattern; -//# sourceMappingURL=internal-pattern.js.map - -/***/ }), - -/***/ 89117: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.SearchState = void 0; -class SearchState { - constructor(path, level) { - this.path = path; - this.level = level; - } -} -exports.SearchState = SearchState; -//# sourceMappingURL=internal-search-state.js.map - -/***/ }), - -/***/ 35526: -/***/ (function(__unused_webpack_module, exports) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = void 0; -class BasicCredentialHandler { - constructor(username, password) { - this.username = username; - this.password = password; - } - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); - } - options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); - }); - } -} -exports.BasicCredentialHandler = BasicCredentialHandler; -class BearerCredentialHandler { - constructor(token) { - this.token = token; - } - // currently implements pre-authorization - // TODO: support preAuth = false where it hooks on 401 - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); - } - options.headers['Authorization'] = `Bearer ${this.token}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); - }); - } -} -exports.BearerCredentialHandler = BearerCredentialHandler; -class PersonalAccessTokenCredentialHandler { - constructor(token) { - this.token = token; - } - // currently implements pre-authorization - // TODO: support preAuth = false where it hooks on 401 - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); - } - options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); - }); - } -} -exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; -//# sourceMappingURL=auth.js.map - -/***/ }), - -/***/ 96255: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -/* eslint-disable @typescript-eslint/no-explicit-any */ -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; -const http = __importStar(__nccwpck_require__(13685)); -const https = __importStar(__nccwpck_require__(95687)); -const pm = __importStar(__nccwpck_require__(19835)); -const tunnel = __importStar(__nccwpck_require__(74294)); -var HttpCodes; -(function (HttpCodes) { - HttpCodes[HttpCodes["OK"] = 200] = "OK"; - HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; - HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; - HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; - HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; - HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; - HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; - HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; - HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; - HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; - HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; - HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; - HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; - HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; - HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; - HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; - HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; - HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; - HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; - HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; - HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; - HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; - HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; - HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; - HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; - HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; - HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; -})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); -var Headers; -(function (Headers) { - Headers["Accept"] = "accept"; - Headers["ContentType"] = "content-type"; -})(Headers = exports.Headers || (exports.Headers = {})); -var MediaTypes; -(function (MediaTypes) { - MediaTypes["ApplicationJson"] = "application/json"; -})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); -/** - * Returns the proxy URL, depending upon the supplied url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ -function getProxyUrl(serverUrl) { - const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); - return proxyUrl ? proxyUrl.href : ''; -} -exports.getProxyUrl = getProxyUrl; -const HttpRedirectCodes = [ - HttpCodes.MovedPermanently, - HttpCodes.ResourceMoved, - HttpCodes.SeeOther, - HttpCodes.TemporaryRedirect, - HttpCodes.PermanentRedirect -]; -const HttpResponseRetryCodes = [ - HttpCodes.BadGateway, - HttpCodes.ServiceUnavailable, - HttpCodes.GatewayTimeout -]; -const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; -const ExponentialBackoffCeiling = 10; -const ExponentialBackoffTimeSlice = 5; -class HttpClientError extends Error { - constructor(message, statusCode) { - super(message); - this.name = 'HttpClientError'; - this.statusCode = statusCode; - Object.setPrototypeOf(this, HttpClientError.prototype); - } -} -exports.HttpClientError = HttpClientError; -class HttpClientResponse { - constructor(message) { - this.message = message; - } - readBody() { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { - let output = Buffer.alloc(0); - this.message.on('data', (chunk) => { - output = Buffer.concat([output, chunk]); - }); - this.message.on('end', () => { - resolve(output.toString()); - }); - })); - }); - } -} -exports.HttpClientResponse = HttpClientResponse; -function isHttps(requestUrl) { - const parsedUrl = new URL(requestUrl); - return parsedUrl.protocol === 'https:'; -} -exports.isHttps = isHttps; -class HttpClient { - constructor(userAgent, handlers, requestOptions) { - this._ignoreSslError = false; - this._allowRedirects = true; - this._allowRedirectDowngrade = false; - this._maxRedirects = 50; - this._allowRetries = false; - this._maxRetries = 1; - this._keepAlive = false; - this._disposed = false; - this.userAgent = userAgent; - this.handlers = handlers || []; - this.requestOptions = requestOptions; - if (requestOptions) { - if (requestOptions.ignoreSslError != null) { - this._ignoreSslError = requestOptions.ignoreSslError; - } - this._socketTimeout = requestOptions.socketTimeout; - if (requestOptions.allowRedirects != null) { - this._allowRedirects = requestOptions.allowRedirects; - } - if (requestOptions.allowRedirectDowngrade != null) { - this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; - } - if (requestOptions.maxRedirects != null) { - this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); - } - if (requestOptions.keepAlive != null) { - this._keepAlive = requestOptions.keepAlive; - } - if (requestOptions.allowRetries != null) { - this._allowRetries = requestOptions.allowRetries; - } - if (requestOptions.maxRetries != null) { - this._maxRetries = requestOptions.maxRetries; - } - } - } - options(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); - }); - } - get(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('GET', requestUrl, null, additionalHeaders || {}); - }); - } - del(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('DELETE', requestUrl, null, additionalHeaders || {}); - }); - } - post(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('POST', requestUrl, data, additionalHeaders || {}); - }); - } - patch(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('PATCH', requestUrl, data, additionalHeaders || {}); - }); - } - put(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('PUT', requestUrl, data, additionalHeaders || {}); - }); - } - head(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('HEAD', requestUrl, null, additionalHeaders || {}); - }); - } - sendStream(verb, requestUrl, stream, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request(verb, requestUrl, stream, additionalHeaders); - }); - } - /** - * Gets a typed object from an endpoint - * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise - */ - getJson(requestUrl, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - const res = yield this.get(requestUrl, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - postJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.post(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - putJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.put(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - patchJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.patch(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - /** - * Makes a raw http request. - * All other methods such as get, post, patch, and request ultimately call this. - * Prefer get, del, post and patch - */ - request(verb, requestUrl, data, headers) { - return __awaiter(this, void 0, void 0, function* () { - if (this._disposed) { - throw new Error('Client has already been disposed.'); - } - const parsedUrl = new URL(requestUrl); - let info = this._prepareRequest(verb, parsedUrl, headers); - // Only perform retries on reads since writes may not be idempotent. - const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) - ? this._maxRetries + 1 - : 1; - let numTries = 0; - let response; - do { - response = yield this.requestRaw(info, data); - // Check if it's an authentication challenge - if (response && - response.message && - response.message.statusCode === HttpCodes.Unauthorized) { - let authenticationHandler; - for (const handler of this.handlers) { - if (handler.canHandleAuthentication(response)) { - authenticationHandler = handler; - break; - } - } - if (authenticationHandler) { - return authenticationHandler.handleAuthentication(this, info, data); - } - else { - // We have received an unauthorized response but have no handlers to handle it. - // Let the response return to the caller. - return response; - } - } - let redirectsRemaining = this._maxRedirects; - while (response.message.statusCode && - HttpRedirectCodes.includes(response.message.statusCode) && - this._allowRedirects && - redirectsRemaining > 0) { - const redirectUrl = response.message.headers['location']; - if (!redirectUrl) { - // if there's no location to redirect to, we won't - break; - } - const parsedRedirectUrl = new URL(redirectUrl); - if (parsedUrl.protocol === 'https:' && - parsedUrl.protocol !== parsedRedirectUrl.protocol && - !this._allowRedirectDowngrade) { - throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); - } - // we need to finish reading the response before reassigning response - // which will leak the open socket. - yield response.readBody(); - // strip authorization header if redirected to a different hostname - if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { - for (const header in headers) { - // header names are case insensitive - if (header.toLowerCase() === 'authorization') { - delete headers[header]; - } - } - } - // let's make the request with the new redirectUrl - info = this._prepareRequest(verb, parsedRedirectUrl, headers); - response = yield this.requestRaw(info, data); - redirectsRemaining--; - } - if (!response.message.statusCode || - !HttpResponseRetryCodes.includes(response.message.statusCode)) { - // If not a retry code, return immediately instead of retrying - return response; - } - numTries += 1; - if (numTries < maxTries) { - yield response.readBody(); - yield this._performExponentialBackoff(numTries); - } - } while (numTries < maxTries); - return response; - }); - } - /** - * Needs to be called if keepAlive is set to true in request options. - */ - dispose() { - if (this._agent) { - this._agent.destroy(); - } - this._disposed = true; - } - /** - * Raw request. - * @param info - * @param data - */ - requestRaw(info, data) { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve, reject) => { - function callbackForResult(err, res) { - if (err) { - reject(err); - } - else if (!res) { - // If `err` is not passed, then `res` must be passed. - reject(new Error('Unknown error')); - } - else { - resolve(res); - } - } - this.requestRawWithCallback(info, data, callbackForResult); - }); - }); - } - /** - * Raw request with callback. - * @param info - * @param data - * @param onResult - */ - requestRawWithCallback(info, data, onResult) { - if (typeof data === 'string') { - if (!info.options.headers) { - info.options.headers = {}; - } - info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); - } - let callbackCalled = false; - function handleResult(err, res) { - if (!callbackCalled) { - callbackCalled = true; - onResult(err, res); - } - } - const req = info.httpModule.request(info.options, (msg) => { - const res = new HttpClientResponse(msg); - handleResult(undefined, res); - }); - let socket; - req.on('socket', sock => { - socket = sock; - }); - // If we ever get disconnected, we want the socket to timeout eventually - req.setTimeout(this._socketTimeout || 3 * 60000, () => { - if (socket) { - socket.end(); - } - handleResult(new Error(`Request timeout: ${info.options.path}`)); - }); - req.on('error', function (err) { - // err has statusCode property - // res should have headers - handleResult(err); - }); - if (data && typeof data === 'string') { - req.write(data, 'utf8'); - } - if (data && typeof data !== 'string') { - data.on('close', function () { - req.end(); - }); - data.pipe(req); - } - else { - req.end(); - } - } - /** - * Gets an http agent. This function is useful when you need an http agent that handles - * routing through a proxy server - depending upon the url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ - getAgent(serverUrl) { - const parsedUrl = new URL(serverUrl); - return this._getAgent(parsedUrl); - } - _prepareRequest(method, requestUrl, headers) { - const info = {}; - info.parsedUrl = requestUrl; - const usingSsl = info.parsedUrl.protocol === 'https:'; - info.httpModule = usingSsl ? https : http; - const defaultPort = usingSsl ? 443 : 80; - info.options = {}; - info.options.host = info.parsedUrl.hostname; - info.options.port = info.parsedUrl.port - ? parseInt(info.parsedUrl.port) - : defaultPort; - info.options.path = - (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); - info.options.method = method; - info.options.headers = this._mergeHeaders(headers); - if (this.userAgent != null) { - info.options.headers['user-agent'] = this.userAgent; - } - info.options.agent = this._getAgent(info.parsedUrl); - // gives handlers an opportunity to participate - if (this.handlers) { - for (const handler of this.handlers) { - handler.prepareRequest(info.options); - } - } - return info; - } - _mergeHeaders(headers) { - if (this.requestOptions && this.requestOptions.headers) { - return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); - } - return lowercaseKeys(headers || {}); - } - _getExistingOrDefaultHeader(additionalHeaders, header, _default) { - let clientHeader; - if (this.requestOptions && this.requestOptions.headers) { - clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; - } - return additionalHeaders[header] || clientHeader || _default; - } - _getAgent(parsedUrl) { - let agent; - const proxyUrl = pm.getProxyUrl(parsedUrl); - const useProxy = proxyUrl && proxyUrl.hostname; - if (this._keepAlive && useProxy) { - agent = this._proxyAgent; - } - if (this._keepAlive && !useProxy) { - agent = this._agent; - } - // if agent is already assigned use that agent. - if (agent) { - return agent; - } - const usingSsl = parsedUrl.protocol === 'https:'; - let maxSockets = 100; - if (this.requestOptions) { - maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; - } - // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. - if (proxyUrl && proxyUrl.hostname) { - const agentOptions = { - maxSockets, - keepAlive: this._keepAlive, - proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && { - proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` - })), { host: proxyUrl.hostname, port: proxyUrl.port }) - }; - let tunnelAgent; - const overHttps = proxyUrl.protocol === 'https:'; - if (usingSsl) { - tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; - } - else { - tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; - } - agent = tunnelAgent(agentOptions); - this._proxyAgent = agent; - } - // if reusing agent across request and tunneling agent isn't assigned create a new agent - if (this._keepAlive && !agent) { - const options = { keepAlive: this._keepAlive, maxSockets }; - agent = usingSsl ? new https.Agent(options) : new http.Agent(options); - this._agent = agent; - } - // if not using private agent and tunnel agent isn't setup then use global agent - if (!agent) { - agent = usingSsl ? https.globalAgent : http.globalAgent; - } - if (usingSsl && this._ignoreSslError) { - // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process - // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options - // we have to cast it to any and change it directly - agent.options = Object.assign(agent.options || {}, { - rejectUnauthorized: false - }); - } - return agent; - } - _performExponentialBackoff(retryNumber) { - return __awaiter(this, void 0, void 0, function* () { - retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); - const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); - return new Promise(resolve => setTimeout(() => resolve(), ms)); - }); - } - _processResponse(res, options) { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { - const statusCode = res.message.statusCode || 0; - const response = { - statusCode, - result: null, - headers: {} - }; - // not found leads to null obj returned - if (statusCode === HttpCodes.NotFound) { - resolve(response); - } - // get the result from the body - function dateTimeDeserializer(key, value) { - if (typeof value === 'string') { - const a = new Date(value); - if (!isNaN(a.valueOf())) { - return a; - } - } - return value; - } - let obj; - let contents; - try { - contents = yield res.readBody(); - if (contents && contents.length > 0) { - if (options && options.deserializeDates) { - obj = JSON.parse(contents, dateTimeDeserializer); - } - else { - obj = JSON.parse(contents); - } - response.result = obj; - } - response.headers = res.message.headers; - } - catch (err) { - // Invalid resource (contents not json); leaving result obj null - } - // note that 3xx redirects are handled by the http layer. - if (statusCode > 299) { - let msg; - // if exception/error in body, attempt to get better error - if (obj && obj.message) { - msg = obj.message; - } - else if (contents && contents.length > 0) { - // it may be the case that the exception is in the body message as string - msg = contents; - } - else { - msg = `Failed request: (${statusCode})`; - } - const err = new HttpClientError(msg, statusCode); - err.result = response.result; - reject(err); - } - else { - resolve(response); - } - })); - }); - } -} -exports.HttpClient = HttpClient; -const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 19835: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.checkBypass = exports.getProxyUrl = void 0; -function getProxyUrl(reqUrl) { - const usingSsl = reqUrl.protocol === 'https:'; - if (checkBypass(reqUrl)) { - return undefined; - } - const proxyVar = (() => { - if (usingSsl) { - return process.env['https_proxy'] || process.env['HTTPS_PROXY']; - } - else { - return process.env['http_proxy'] || process.env['HTTP_PROXY']; - } - })(); - if (proxyVar) { - return new URL(proxyVar); - } - else { - return undefined; - } -} -exports.getProxyUrl = getProxyUrl; -function checkBypass(reqUrl) { - if (!reqUrl.hostname) { - return false; - } - const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; - if (!noProxy) { - return false; - } - // Determine the request port - let reqPort; - if (reqUrl.port) { - reqPort = Number(reqUrl.port); - } - else if (reqUrl.protocol === 'http:') { - reqPort = 80; - } - else if (reqUrl.protocol === 'https:') { - reqPort = 443; - } - // Format the request hostname and hostname with port - const upperReqHosts = [reqUrl.hostname.toUpperCase()]; - if (typeof reqPort === 'number') { - upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); - } - // Compare request host against noproxy - for (const upperNoProxyItem of noProxy - .split(',') - .map(x => x.trim().toUpperCase()) - .filter(x => x)) { - if (upperReqHosts.some(x => x === upperNoProxyItem)) { - return true; - } - } - return false; -} -exports.checkBypass = checkBypass; -//# sourceMappingURL=proxy.js.map - -/***/ }), - -/***/ 9417: -/***/ ((module) => { - -"use strict"; - -module.exports = balanced; -function balanced(a, b, str) { - if (a instanceof RegExp) a = maybeMatch(a, str); - if (b instanceof RegExp) b = maybeMatch(b, str); - - var r = range(a, b, str); - - return r && { - start: r[0], - end: r[1], - pre: str.slice(0, r[0]), - body: str.slice(r[0] + a.length, r[1]), - post: str.slice(r[1] + b.length) - }; -} - -function maybeMatch(reg, str) { - var m = str.match(reg); - return m ? m[0] : null; -} - -balanced.range = range; -function range(a, b, str) { - var begs, beg, left, right, result; - var ai = str.indexOf(a); - var bi = str.indexOf(b, ai + 1); - var i = ai; - - if (ai >= 0 && bi > 0) { - begs = []; - left = str.length; - - while (i >= 0 && !result) { - if (i == ai) { - begs.push(i); - ai = str.indexOf(a, i + 1); - } else if (begs.length == 1) { - result = [ begs.pop(), bi ]; - } else { - beg = begs.pop(); - if (beg < left) { - left = beg; - right = bi; - } - - bi = str.indexOf(b, i + 1); - } - - i = ai < bi && ai >= 0 ? ai : bi; - } - - if (begs.length) { - result = [ left, right ]; - } - } - - return result; -} - - -/***/ }), - -/***/ 33717: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var concatMap = __nccwpck_require__(86891); -var balanced = __nccwpck_require__(9417); - -module.exports = expandTop; - -var escSlash = '\0SLASH'+Math.random()+'\0'; -var escOpen = '\0OPEN'+Math.random()+'\0'; -var escClose = '\0CLOSE'+Math.random()+'\0'; -var escComma = '\0COMMA'+Math.random()+'\0'; -var escPeriod = '\0PERIOD'+Math.random()+'\0'; - -function numeric(str) { - return parseInt(str, 10) == str - ? parseInt(str, 10) - : str.charCodeAt(0); -} - -function escapeBraces(str) { - return str.split('\\\\').join(escSlash) - .split('\\{').join(escOpen) - .split('\\}').join(escClose) - .split('\\,').join(escComma) - .split('\\.').join(escPeriod); -} - -function unescapeBraces(str) { - return str.split(escSlash).join('\\') - .split(escOpen).join('{') - .split(escClose).join('}') - .split(escComma).join(',') - .split(escPeriod).join('.'); -} - - -// Basically just str.split(","), but handling cases -// where we have nested braced sections, which should be -// treated as individual members, like {a,{b,c},d} -function parseCommaParts(str) { - if (!str) - return ['']; - - var parts = []; - var m = balanced('{', '}', str); - - if (!m) - return str.split(','); - - var pre = m.pre; - var body = m.body; - var post = m.post; - var p = pre.split(','); - - p[p.length-1] += '{' + body + '}'; - var postParts = parseCommaParts(post); - if (post.length) { - p[p.length-1] += postParts.shift(); - p.push.apply(p, postParts); - } - - parts.push.apply(parts, p); - - return parts; -} - -function expandTop(str) { - if (!str) - return []; - - // I don't know why Bash 4.3 does this, but it does. - // Anything starting with {} will have the first two bytes preserved - // but *only* at the top level, so {},a}b will not expand to anything, - // but a{},b}c will be expanded to [a}c,abc]. - // One could argue that this is a bug in Bash, but since the goal of - // this module is to match Bash's rules, we escape a leading {} - if (str.substr(0, 2) === '{}') { - str = '\\{\\}' + str.substr(2); - } - - return expand(escapeBraces(str), true).map(unescapeBraces); -} - -function identity(e) { - return e; -} - -function embrace(str) { - return '{' + str + '}'; -} -function isPadded(el) { - return /^-?0\d/.test(el); -} - -function lte(i, y) { - return i <= y; -} -function gte(i, y) { - return i >= y; -} - -function expand(str, isTop) { - var expansions = []; - - var m = balanced('{', '}', str); - if (!m || /\$$/.test(m.pre)) return [str]; - - var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); - var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); - var isSequence = isNumericSequence || isAlphaSequence; - var isOptions = m.body.indexOf(',') >= 0; - if (!isSequence && !isOptions) { - // {a},b} - if (m.post.match(/,.*\}/)) { - str = m.pre + '{' + m.body + escClose + m.post; - return expand(str); - } - return [str]; - } - - var n; - if (isSequence) { - n = m.body.split(/\.\./); - } else { - n = parseCommaParts(m.body); - if (n.length === 1) { - // x{{a,b}}y ==> x{a}y x{b}y - n = expand(n[0], false).map(embrace); - if (n.length === 1) { - var post = m.post.length - ? expand(m.post, false) - : ['']; - return post.map(function(p) { - return m.pre + n[0] + p; - }); - } - } - } - - // at this point, n is the parts, and we know it's not a comma set - // with a single entry. - - // no need to expand pre, since it is guaranteed to be free of brace-sets - var pre = m.pre; - var post = m.post.length - ? expand(m.post, false) - : ['']; - - var N; - - if (isSequence) { - var x = numeric(n[0]); - var y = numeric(n[1]); - var width = Math.max(n[0].length, n[1].length) - var incr = n.length == 3 - ? Math.abs(numeric(n[2])) - : 1; - var test = lte; - var reverse = y < x; - if (reverse) { - incr *= -1; - test = gte; - } - var pad = n.some(isPadded); - - N = []; - - for (var i = x; test(i, y); i += incr) { - var c; - if (isAlphaSequence) { - c = String.fromCharCode(i); - if (c === '\\') - c = ''; - } else { - c = String(i); - if (pad) { - var need = width - c.length; - if (need > 0) { - var z = new Array(need + 1).join('0'); - if (i < 0) - c = '-' + z + c.slice(1); - else - c = z + c; - } - } - } - N.push(c); - } - } else { - N = concatMap(n, function(el) { return expand(el, false) }); - } - - for (var j = 0; j < N.length; j++) { - for (var k = 0; k < post.length; k++) { - var expansion = pre + N[j] + post[k]; - if (!isTop || isSequence || expansion) - expansions.push(expansion); - } - } - - return expansions; -} - - - -/***/ }), - -/***/ 86891: -/***/ ((module) => { - -module.exports = function (xs, fn) { - var res = []; - for (var i = 0; i < xs.length; i++) { - var x = fn(xs[i], i); - if (isArray(x)) res.push.apply(res, x); - else res.push(x); - } - return res; -}; - -var isArray = Array.isArray || function (xs) { - return Object.prototype.toString.call(xs) === '[object Array]'; -}; - - -/***/ }), - -/***/ 83973: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -module.exports = minimatch -minimatch.Minimatch = Minimatch - -var path = (function () { try { return __nccwpck_require__(71017) } catch (e) {}}()) || { - sep: '/' -} -minimatch.sep = path.sep - -var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} -var expand = __nccwpck_require__(33717) - -var plTypes = { - '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, - '?': { open: '(?:', close: ')?' }, - '+': { open: '(?:', close: ')+' }, - '*': { open: '(?:', close: ')*' }, - '@': { open: '(?:', close: ')' } -} - -// any single thing other than / -// don't need to escape / when using new RegExp() -var qmark = '[^/]' - -// * => any number of characters -var star = qmark + '*?' - -// ** when dots are allowed. Anything goes, except .. and . -// not (^ or / followed by one or two dots followed by $ or /), -// followed by anything, any number of times. -var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' - -// not a ^ or / followed by a dot, -// followed by anything, any number of times. -var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' - -// characters that need to be escaped in RegExp. -var reSpecials = charSet('().*{}+?[]^$\\!') - -// "abc" -> { a:true, b:true, c:true } -function charSet (s) { - return s.split('').reduce(function (set, c) { - set[c] = true - return set - }, {}) -} - -// normalizes slashes. -var slashSplit = /\/+/ - -minimatch.filter = filter -function filter (pattern, options) { - options = options || {} - return function (p, i, list) { - return minimatch(p, pattern, options) - } -} - -function ext (a, b) { - b = b || {} - var t = {} - Object.keys(a).forEach(function (k) { - t[k] = a[k] - }) - Object.keys(b).forEach(function (k) { - t[k] = b[k] - }) - return t -} - -minimatch.defaults = function (def) { - if (!def || typeof def !== 'object' || !Object.keys(def).length) { - return minimatch - } - - var orig = minimatch - - var m = function minimatch (p, pattern, options) { - return orig(p, pattern, ext(def, options)) - } - - m.Minimatch = function Minimatch (pattern, options) { - return new orig.Minimatch(pattern, ext(def, options)) - } - m.Minimatch.defaults = function defaults (options) { - return orig.defaults(ext(def, options)).Minimatch - } - - m.filter = function filter (pattern, options) { - return orig.filter(pattern, ext(def, options)) - } - - m.defaults = function defaults (options) { - return orig.defaults(ext(def, options)) - } - - m.makeRe = function makeRe (pattern, options) { - return orig.makeRe(pattern, ext(def, options)) - } - - m.braceExpand = function braceExpand (pattern, options) { - return orig.braceExpand(pattern, ext(def, options)) - } - - m.match = function (list, pattern, options) { - return orig.match(list, pattern, ext(def, options)) - } - - return m -} - -Minimatch.defaults = function (def) { - return minimatch.defaults(def).Minimatch -} - -function minimatch (p, pattern, options) { - assertValidPattern(pattern) - - if (!options) options = {} - - // shortcut: comments match nothing. - if (!options.nocomment && pattern.charAt(0) === '#') { - return false - } - - return new Minimatch(pattern, options).match(p) -} - -function Minimatch (pattern, options) { - if (!(this instanceof Minimatch)) { - return new Minimatch(pattern, options) - } - - assertValidPattern(pattern) - - if (!options) options = {} - - pattern = pattern.trim() - - // windows support: need to use /, not \ - if (!options.allowWindowsEscape && path.sep !== '/') { - pattern = pattern.split(path.sep).join('/') - } - - this.options = options - this.set = [] - this.pattern = pattern - this.regexp = null - this.negate = false - this.comment = false - this.empty = false - this.partial = !!options.partial - - // make the set of regexps etc. - this.make() -} - -Minimatch.prototype.debug = function () {} - -Minimatch.prototype.make = make -function make () { - var pattern = this.pattern - var options = this.options - - // empty patterns and comments match nothing. - if (!options.nocomment && pattern.charAt(0) === '#') { - this.comment = true - return - } - if (!pattern) { - this.empty = true - return - } - - // step 1: figure out negation, etc. - this.parseNegate() - - // step 2: expand braces - var set = this.globSet = this.braceExpand() - - if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) } - - this.debug(this.pattern, set) - - // step 3: now we have a set, so turn each one into a series of path-portion - // matching patterns. - // These will be regexps, except in the case of "**", which is - // set to the GLOBSTAR object for globstar behavior, - // and will not contain any / characters - set = this.globParts = set.map(function (s) { - return s.split(slashSplit) - }) - - this.debug(this.pattern, set) - - // glob --> regexps - set = set.map(function (s, si, set) { - return s.map(this.parse, this) - }, this) - - this.debug(this.pattern, set) - - // filter out everything that didn't compile properly. - set = set.filter(function (s) { - return s.indexOf(false) === -1 - }) - - this.debug(this.pattern, set) - - this.set = set -} - -Minimatch.prototype.parseNegate = parseNegate -function parseNegate () { - var pattern = this.pattern - var negate = false - var options = this.options - var negateOffset = 0 - - if (options.nonegate) return - - for (var i = 0, l = pattern.length - ; i < l && pattern.charAt(i) === '!' - ; i++) { - negate = !negate - negateOffset++ - } - - if (negateOffset) this.pattern = pattern.substr(negateOffset) - this.negate = negate -} - -// Brace expansion: -// a{b,c}d -> abd acd -// a{b,}c -> abc ac -// a{0..3}d -> a0d a1d a2d a3d -// a{b,c{d,e}f}g -> abg acdfg acefg -// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg -// -// Invalid sets are not expanded. -// a{2..}b -> a{2..}b -// a{b}c -> a{b}c -minimatch.braceExpand = function (pattern, options) { - return braceExpand(pattern, options) -} - -Minimatch.prototype.braceExpand = braceExpand - -function braceExpand (pattern, options) { - if (!options) { - if (this instanceof Minimatch) { - options = this.options - } else { - options = {} - } - } - - pattern = typeof pattern === 'undefined' - ? this.pattern : pattern - - assertValidPattern(pattern) - - // Thanks to Yeting Li for - // improving this regexp to avoid a ReDOS vulnerability. - if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) { - // shortcut. no need to expand. - return [pattern] - } - - return expand(pattern) -} - -var MAX_PATTERN_LENGTH = 1024 * 64 -var assertValidPattern = function (pattern) { - if (typeof pattern !== 'string') { - throw new TypeError('invalid pattern') - } - - if (pattern.length > MAX_PATTERN_LENGTH) { - throw new TypeError('pattern is too long') - } -} - -// parse a component of the expanded set. -// At this point, no pattern may contain "/" in it -// so we're going to return a 2d array, where each entry is the full -// pattern, split on '/', and then turned into a regular expression. -// A regexp is made at the end which joins each array with an -// escaped /, and another full one which joins each regexp with |. -// -// Following the lead of Bash 4.1, note that "**" only has special meaning -// when it is the *only* thing in a path portion. Otherwise, any series -// of * is equivalent to a single *. Globstar behavior is enabled by -// default, and can be disabled by setting options.noglobstar. -Minimatch.prototype.parse = parse -var SUBPARSE = {} -function parse (pattern, isSub) { - assertValidPattern(pattern) - - var options = this.options - - // shortcuts - if (pattern === '**') { - if (!options.noglobstar) - return GLOBSTAR - else - pattern = '*' - } - if (pattern === '') return '' - - var re = '' - var hasMagic = !!options.nocase - var escaping = false - // ? => one single character - var patternListStack = [] - var negativeLists = [] - var stateChar - var inClass = false - var reClassStart = -1 - var classStart = -1 - // . and .. never match anything that doesn't start with ., - // even when options.dot is set. - var patternStart = pattern.charAt(0) === '.' ? '' // anything - // not (start or / followed by . or .. followed by / or end) - : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' - : '(?!\\.)' - var self = this - - function clearStateChar () { - if (stateChar) { - // we had some state-tracking character - // that wasn't consumed by this pass. - switch (stateChar) { - case '*': - re += star - hasMagic = true - break - case '?': - re += qmark - hasMagic = true - break - default: - re += '\\' + stateChar - break - } - self.debug('clearStateChar %j %j', stateChar, re) - stateChar = false - } - } - - for (var i = 0, len = pattern.length, c - ; (i < len) && (c = pattern.charAt(i)) - ; i++) { - this.debug('%s\t%s %s %j', pattern, i, re, c) - - // skip over any that are escaped. - if (escaping && reSpecials[c]) { - re += '\\' + c - escaping = false - continue - } - - switch (c) { - /* istanbul ignore next */ - case '/': { - // completely not allowed, even escaped. - // Should already be path-split by now. - return false - } - - case '\\': - clearStateChar() - escaping = true - continue - - // the various stateChar values - // for the "extglob" stuff. - case '?': - case '*': - case '+': - case '@': - case '!': - this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) - - // all of those are literals inside a class, except that - // the glob [!a] means [^a] in regexp - if (inClass) { - this.debug(' in class') - if (c === '!' && i === classStart + 1) c = '^' - re += c - continue - } - - // if we already have a stateChar, then it means - // that there was something like ** or +? in there. - // Handle the stateChar, then proceed with this one. - self.debug('call clearStateChar %j', stateChar) - clearStateChar() - stateChar = c - // if extglob is disabled, then +(asdf|foo) isn't a thing. - // just clear the statechar *now*, rather than even diving into - // the patternList stuff. - if (options.noext) clearStateChar() - continue - - case '(': - if (inClass) { - re += '(' - continue - } - - if (!stateChar) { - re += '\\(' - continue - } - - patternListStack.push({ - type: stateChar, - start: i - 1, - reStart: re.length, - open: plTypes[stateChar].open, - close: plTypes[stateChar].close - }) - // negation is (?:(?!js)[^/]*) - re += stateChar === '!' ? '(?:(?!(?:' : '(?:' - this.debug('plType %j %j', stateChar, re) - stateChar = false - continue - - case ')': - if (inClass || !patternListStack.length) { - re += '\\)' - continue - } - - clearStateChar() - hasMagic = true - var pl = patternListStack.pop() - // negation is (?:(?!js)[^/]*) - // The others are (?:) - re += pl.close - if (pl.type === '!') { - negativeLists.push(pl) - } - pl.reEnd = re.length - continue - - case '|': - if (inClass || !patternListStack.length || escaping) { - re += '\\|' - escaping = false - continue - } - - clearStateChar() - re += '|' - continue - - // these are mostly the same in regexp and glob - case '[': - // swallow any state-tracking char before the [ - clearStateChar() - - if (inClass) { - re += '\\' + c - continue - } - - inClass = true - classStart = i - reClassStart = re.length - re += c - continue - - case ']': - // a right bracket shall lose its special - // meaning and represent itself in - // a bracket expression if it occurs - // first in the list. -- POSIX.2 2.8.3.2 - if (i === classStart + 1 || !inClass) { - re += '\\' + c - escaping = false - continue - } - - // handle the case where we left a class open. - // "[z-a]" is valid, equivalent to "\[z-a\]" - // split where the last [ was, make sure we don't have - // an invalid re. if so, re-walk the contents of the - // would-be class to re-translate any characters that - // were passed through as-is - // TODO: It would probably be faster to determine this - // without a try/catch and a new RegExp, but it's tricky - // to do safely. For now, this is safe and works. - var cs = pattern.substring(classStart + 1, i) - try { - RegExp('[' + cs + ']') - } catch (er) { - // not a valid class! - var sp = this.parse(cs, SUBPARSE) - re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' - hasMagic = hasMagic || sp[1] - inClass = false - continue - } - - // finish up the class. - hasMagic = true - inClass = false - re += c - continue - - default: - // swallow any state char that wasn't consumed - clearStateChar() - - if (escaping) { - // no need - escaping = false - } else if (reSpecials[c] - && !(c === '^' && inClass)) { - re += '\\' - } - - re += c - - } // switch - } // for - - // handle the case where we left a class open. - // "[abc" is valid, equivalent to "\[abc" - if (inClass) { - // split where the last [ was, and escape it - // this is a huge pita. We now have to re-walk - // the contents of the would-be class to re-translate - // any characters that were passed through as-is - cs = pattern.substr(classStart + 1) - sp = this.parse(cs, SUBPARSE) - re = re.substr(0, reClassStart) + '\\[' + sp[0] - hasMagic = hasMagic || sp[1] - } - - // handle the case where we had a +( thing at the *end* - // of the pattern. - // each pattern list stack adds 3 chars, and we need to go through - // and escape any | chars that were passed through as-is for the regexp. - // Go through and escape them, taking care not to double-escape any - // | chars that were already escaped. - for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { - var tail = re.slice(pl.reStart + pl.open.length) - this.debug('setting tail', re, pl) - // maybe some even number of \, then maybe 1 \, followed by a | - tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { - if (!$2) { - // the | isn't already escaped, so escape it. - $2 = '\\' - } - - // need to escape all those slashes *again*, without escaping the - // one that we need for escaping the | character. As it works out, - // escaping an even number of slashes can be done by simply repeating - // it exactly after itself. That's why this trick works. - // - // I am sorry that you have to see this. - return $1 + $1 + $2 + '|' - }) - - this.debug('tail=%j\n %s', tail, tail, pl, re) - var t = pl.type === '*' ? star - : pl.type === '?' ? qmark - : '\\' + pl.type - - hasMagic = true - re = re.slice(0, pl.reStart) + t + '\\(' + tail - } - - // handle trailing things that only matter at the very end. - clearStateChar() - if (escaping) { - // trailing \\ - re += '\\\\' - } - - // only need to apply the nodot start if the re starts with - // something that could conceivably capture a dot - var addPatternStart = false - switch (re.charAt(0)) { - case '[': case '.': case '(': addPatternStart = true - } - - // Hack to work around lack of negative lookbehind in JS - // A pattern like: *.!(x).!(y|z) needs to ensure that a name - // like 'a.xyz.yz' doesn't match. So, the first negative - // lookahead, has to look ALL the way ahead, to the end of - // the pattern. - for (var n = negativeLists.length - 1; n > -1; n--) { - var nl = negativeLists[n] - - var nlBefore = re.slice(0, nl.reStart) - var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) - var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) - var nlAfter = re.slice(nl.reEnd) - - nlLast += nlAfter - - // Handle nested stuff like *(*.js|!(*.json)), where open parens - // mean that we should *not* include the ) in the bit that is considered - // "after" the negated section. - var openParensBefore = nlBefore.split('(').length - 1 - var cleanAfter = nlAfter - for (i = 0; i < openParensBefore; i++) { - cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') - } - nlAfter = cleanAfter - - var dollar = '' - if (nlAfter === '' && isSub !== SUBPARSE) { - dollar = '$' - } - var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast - re = newRe - } - - // if the re is not "" at this point, then we need to make sure - // it doesn't match against an empty path part. - // Otherwise a/* will match a/, which it should not. - if (re !== '' && hasMagic) { - re = '(?=.)' + re - } - - if (addPatternStart) { - re = patternStart + re - } - - // parsing just a piece of a larger pattern. - if (isSub === SUBPARSE) { - return [re, hasMagic] - } - - // skip the regexp for non-magical patterns - // unescape anything in it, though, so that it'll be - // an exact match against a file etc. - if (!hasMagic) { - return globUnescape(pattern) - } - - var flags = options.nocase ? 'i' : '' - try { - var regExp = new RegExp('^' + re + '$', flags) - } catch (er) /* istanbul ignore next - should be impossible */ { - // If it was an invalid regular expression, then it can't match - // anything. This trick looks for a character after the end of - // the string, which is of course impossible, except in multi-line - // mode, but it's not a /m regex. - return new RegExp('$.') - } - - regExp._glob = pattern - regExp._src = re - - return regExp -} - -minimatch.makeRe = function (pattern, options) { - return new Minimatch(pattern, options || {}).makeRe() -} - -Minimatch.prototype.makeRe = makeRe -function makeRe () { - if (this.regexp || this.regexp === false) return this.regexp - - // at this point, this.set is a 2d array of partial - // pattern strings, or "**". - // - // It's better to use .match(). This function shouldn't - // be used, really, but it's pretty convenient sometimes, - // when you just want to work with a regex. - var set = this.set - - if (!set.length) { - this.regexp = false - return this.regexp - } - var options = this.options - - var twoStar = options.noglobstar ? star - : options.dot ? twoStarDot - : twoStarNoDot - var flags = options.nocase ? 'i' : '' - - var re = set.map(function (pattern) { - return pattern.map(function (p) { - return (p === GLOBSTAR) ? twoStar - : (typeof p === 'string') ? regExpEscape(p) - : p._src - }).join('\\\/') - }).join('|') - - // must match entire pattern - // ending in a * or ** will make it less strict. - re = '^(?:' + re + ')$' - - // can match anything, as long as it's not this. - if (this.negate) re = '^(?!' + re + ').*$' - - try { - this.regexp = new RegExp(re, flags) - } catch (ex) /* istanbul ignore next - should be impossible */ { - this.regexp = false - } - return this.regexp -} - -minimatch.match = function (list, pattern, options) { - options = options || {} - var mm = new Minimatch(pattern, options) - list = list.filter(function (f) { - return mm.match(f) - }) - if (mm.options.nonull && !list.length) { - list.push(pattern) - } - return list -} - -Minimatch.prototype.match = function match (f, partial) { - if (typeof partial === 'undefined') partial = this.partial - this.debug('match', f, this.pattern) - // short-circuit in the case of busted things. - // comments, etc. - if (this.comment) return false - if (this.empty) return f === '' - - if (f === '/' && partial) return true - - var options = this.options - - // windows: need to use /, not \ - if (path.sep !== '/') { - f = f.split(path.sep).join('/') - } - - // treat the test path as a set of pathparts. - f = f.split(slashSplit) - this.debug(this.pattern, 'split', f) - - // just ONE of the pattern sets in this.set needs to match - // in order for it to be valid. If negating, then just one - // match means that we have failed. - // Either way, return on the first hit. - - var set = this.set - this.debug(this.pattern, 'set', set) - - // Find the basename of the path by looking for the last non-empty segment - var filename - var i - for (i = f.length - 1; i >= 0; i--) { - filename = f[i] - if (filename) break - } - - for (i = 0; i < set.length; i++) { - var pattern = set[i] - var file = f - if (options.matchBase && pattern.length === 1) { - file = [filename] - } - var hit = this.matchOne(file, pattern, partial) - if (hit) { - if (options.flipNegate) return true - return !this.negate - } - } - - // didn't get any hits. this is success if it's a negative - // pattern, failure otherwise. - if (options.flipNegate) return false - return this.negate -} - -// set partial to true to test if, for example, -// "/a/b" matches the start of "/*/b/*/d" -// Partial means, if you run out of file before you run -// out of pattern, then that's fine, as long as all -// the parts match. -Minimatch.prototype.matchOne = function (file, pattern, partial) { - var options = this.options - - this.debug('matchOne', - { 'this': this, file: file, pattern: pattern }) - - this.debug('matchOne', file.length, pattern.length) - - for (var fi = 0, - pi = 0, - fl = file.length, - pl = pattern.length - ; (fi < fl) && (pi < pl) - ; fi++, pi++) { - this.debug('matchOne loop') - var p = pattern[pi] - var f = file[fi] - - this.debug(pattern, p, f) - - // should be impossible. - // some invalid regexp stuff in the set. - /* istanbul ignore if */ - if (p === false) return false - - if (p === GLOBSTAR) { - this.debug('GLOBSTAR', [pattern, p, f]) - - // "**" - // a/**/b/**/c would match the following: - // a/b/x/y/z/c - // a/x/y/z/b/c - // a/b/x/b/x/c - // a/b/c - // To do this, take the rest of the pattern after - // the **, and see if it would match the file remainder. - // If so, return success. - // If not, the ** "swallows" a segment, and try again. - // This is recursively awful. - // - // a/**/b/**/c matching a/b/x/y/z/c - // - a matches a - // - doublestar - // - matchOne(b/x/y/z/c, b/**/c) - // - b matches b - // - doublestar - // - matchOne(x/y/z/c, c) -> no - // - matchOne(y/z/c, c) -> no - // - matchOne(z/c, c) -> no - // - matchOne(c, c) yes, hit - var fr = fi - var pr = pi + 1 - if (pr === pl) { - this.debug('** at the end') - // a ** at the end will just swallow the rest. - // We have found a match. - // however, it will not swallow /.x, unless - // options.dot is set. - // . and .. are *never* matched by **, for explosively - // exponential reasons. - for (; fi < fl; fi++) { - if (file[fi] === '.' || file[fi] === '..' || - (!options.dot && file[fi].charAt(0) === '.')) return false - } - return true - } - - // ok, let's see if we can swallow whatever we can. - while (fr < fl) { - var swallowee = file[fr] - - this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) - - // XXX remove this slice. Just pass the start index. - if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { - this.debug('globstar found match!', fr, fl, swallowee) - // found a match. - return true - } else { - // can't swallow "." or ".." ever. - // can only swallow ".foo" when explicitly asked. - if (swallowee === '.' || swallowee === '..' || - (!options.dot && swallowee.charAt(0) === '.')) { - this.debug('dot detected!', file, fr, pattern, pr) - break - } - - // ** swallows a segment, and continue. - this.debug('globstar swallow a segment, and continue') - fr++ - } - } - - // no match was found. - // However, in partial mode, we can't say this is necessarily over. - // If there's more *pattern* left, then - /* istanbul ignore if */ - if (partial) { - // ran out of file - this.debug('\n>>> no match, partial?', file, fr, pattern, pr) - if (fr === fl) return true - } - return false - } - - // something other than ** - // non-magic patterns just have to match exactly - // patterns with magic have been turned into regexps. - var hit - if (typeof p === 'string') { - hit = f === p - this.debug('string match', p, f, hit) - } else { - hit = f.match(p) - this.debug('pattern match', p, f, hit) - } - - if (!hit) return false - } - - // Note: ending in / means that we'll get a final "" - // at the end of the pattern. This can only match a - // corresponding "" at the end of the file. - // If the file ends in /, then it can only match a - // a pattern that ends in /, unless the pattern just - // doesn't have any more for it. But, a/b/ should *not* - // match "a/b/*", even though "" matches against the - // [^/]*? pattern, except in partial mode, where it might - // simply not be reached yet. - // However, a/b/ should still satisfy a/* - - // now either we fell off the end of the pattern, or we're done. - if (fi === fl && pi === pl) { - // ran out of pattern and filename at the same time. - // an exact hit! - return true - } else if (fi === fl) { - // ran out of file, but still had pattern left. - // this is ok if we're doing the match as part of - // a glob fs traversal. - return partial - } else /* istanbul ignore else */ if (pi === pl) { - // ran out of pattern, still have file left. - // this is only acceptable if we're on the very last - // empty segment of a file with a trailing slash. - // a/* should match a/b/ - return (fi === fl - 1) && (file[fi] === '') - } - - // should be unreachable. - /* istanbul ignore next */ - throw new Error('wtf?') -} - -// replace stuff like \* with * -function globUnescape (s) { - return s.replace(/\\(.)/g, '$1') -} - -function regExpEscape (s) { - return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') -} - - -/***/ }), - -/***/ 74294: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -module.exports = __nccwpck_require__(54219); - - -/***/ }), - -/***/ 54219: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var net = __nccwpck_require__(41808); -var tls = __nccwpck_require__(24404); -var http = __nccwpck_require__(13685); -var https = __nccwpck_require__(95687); -var events = __nccwpck_require__(82361); -var assert = __nccwpck_require__(39491); -var util = __nccwpck_require__(73837); - - -exports.httpOverHttp = httpOverHttp; -exports.httpsOverHttp = httpsOverHttp; -exports.httpOverHttps = httpOverHttps; -exports.httpsOverHttps = httpsOverHttps; - - -function httpOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - return agent; -} - -function httpsOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - agent.createSocket = createSecureSocket; - agent.defaultPort = 443; - return agent; -} - -function httpOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - return agent; -} - -function httpsOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - agent.createSocket = createSecureSocket; - agent.defaultPort = 443; - return agent; -} - - -function TunnelingAgent(options) { - var self = this; - self.options = options || {}; - self.proxyOptions = self.options.proxy || {}; - self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; - self.requests = []; - self.sockets = []; - - self.on('free', function onFree(socket, host, port, localAddress) { - var options = toOptions(host, port, localAddress); - for (var i = 0, len = self.requests.length; i < len; ++i) { - var pending = self.requests[i]; - if (pending.host === options.host && pending.port === options.port) { - // Detect the request to connect same origin server, - // reuse the connection. - self.requests.splice(i, 1); - pending.request.onSocket(socket); - return; - } - } - socket.destroy(); - self.removeSocket(socket); - }); -} -util.inherits(TunnelingAgent, events.EventEmitter); - -TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { - var self = this; - var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); - - if (self.sockets.length >= this.maxSockets) { - // We are over limit so we'll add it to the queue. - self.requests.push(options); - return; - } - - // If we are under maxSockets create a new one. - self.createSocket(options, function(socket) { - socket.on('free', onFree); - socket.on('close', onCloseOrRemove); - socket.on('agentRemove', onCloseOrRemove); - req.onSocket(socket); - - function onFree() { - self.emit('free', socket, options); - } - - function onCloseOrRemove(err) { - self.removeSocket(socket); - socket.removeListener('free', onFree); - socket.removeListener('close', onCloseOrRemove); - socket.removeListener('agentRemove', onCloseOrRemove); - } - }); -}; - -TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { - var self = this; - var placeholder = {}; - self.sockets.push(placeholder); - - var connectOptions = mergeOptions({}, self.proxyOptions, { - method: 'CONNECT', - path: options.host + ':' + options.port, - agent: false, - headers: { - host: options.host + ':' + options.port - } - }); - if (options.localAddress) { - connectOptions.localAddress = options.localAddress; - } - if (connectOptions.proxyAuth) { - connectOptions.headers = connectOptions.headers || {}; - connectOptions.headers['Proxy-Authorization'] = 'Basic ' + - new Buffer(connectOptions.proxyAuth).toString('base64'); - } - - debug('making CONNECT request'); - var connectReq = self.request(connectOptions); - connectReq.useChunkedEncodingByDefault = false; // for v0.6 - connectReq.once('response', onResponse); // for v0.6 - connectReq.once('upgrade', onUpgrade); // for v0.6 - connectReq.once('connect', onConnect); // for v0.7 or later - connectReq.once('error', onError); - connectReq.end(); - - function onResponse(res) { - // Very hacky. This is necessary to avoid http-parser leaks. - res.upgrade = true; - } - - function onUpgrade(res, socket, head) { - // Hacky. - process.nextTick(function() { - onConnect(res, socket, head); - }); - } - - function onConnect(res, socket, head) { - connectReq.removeAllListeners(); - socket.removeAllListeners(); - - if (res.statusCode !== 200) { - debug('tunneling socket could not be established, statusCode=%d', - res.statusCode); - socket.destroy(); - var error = new Error('tunneling socket could not be established, ' + - 'statusCode=' + res.statusCode); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - return; - } - if (head.length > 0) { - debug('got illegal response body from proxy'); - socket.destroy(); - var error = new Error('got illegal response body from proxy'); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - return; - } - debug('tunneling connection has established'); - self.sockets[self.sockets.indexOf(placeholder)] = socket; - return cb(socket); - } - - function onError(cause) { - connectReq.removeAllListeners(); - - debug('tunneling socket could not be established, cause=%s\n', - cause.message, cause.stack); - var error = new Error('tunneling socket could not be established, ' + - 'cause=' + cause.message); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - } -}; - -TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { - var pos = this.sockets.indexOf(socket) - if (pos === -1) { - return; - } - this.sockets.splice(pos, 1); - - var pending = this.requests.shift(); - if (pending) { - // If we have pending requests and a socket gets closed a new one - // needs to be created to take over in the pool for the one that closed. - this.createSocket(pending, function(socket) { - pending.request.onSocket(socket); - }); - } -}; - -function createSecureSocket(options, cb) { - var self = this; - TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { - var hostHeader = options.request.getHeader('host'); - var tlsOptions = mergeOptions({}, self.options, { - socket: socket, - servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host - }); - - // 0 is dummy port for v0.6 - var secureSocket = tls.connect(0, tlsOptions); - self.sockets[self.sockets.indexOf(socket)] = secureSocket; - cb(secureSocket); - }); -} - - -function toOptions(host, port, localAddress) { - if (typeof host === 'string') { // since v0.10 - return { - host: host, - port: port, - localAddress: localAddress - }; - } - return host; // for v0.11 or later -} - -function mergeOptions(target) { - for (var i = 1, len = arguments.length; i < len; ++i) { - var overrides = arguments[i]; - if (typeof overrides === 'object') { - var keys = Object.keys(overrides); - for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { - var k = keys[j]; - if (overrides[k] !== undefined) { - target[k] = overrides[k]; - } - } - } - } - return target; -} - - -var debug; -if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { - debug = function() { - var args = Array.prototype.slice.call(arguments); - if (typeof args[0] === 'string') { - args[0] = 'TUNNEL: ' + args[0]; - } else { - args.unshift('TUNNEL:'); - } - console.error.apply(console, args); - } -} else { - debug = function() {}; -} -exports.debug = debug; // for test - - -/***/ }), - -/***/ 75840: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -Object.defineProperty(exports, "v1", ({ - enumerable: true, - get: function () { - return _v.default; - } -})); -Object.defineProperty(exports, "v3", ({ - enumerable: true, - get: function () { - return _v2.default; - } -})); -Object.defineProperty(exports, "v4", ({ - enumerable: true, - get: function () { - return _v3.default; - } -})); -Object.defineProperty(exports, "v5", ({ - enumerable: true, - get: function () { - return _v4.default; - } -})); -Object.defineProperty(exports, "NIL", ({ - enumerable: true, - get: function () { - return _nil.default; - } -})); -Object.defineProperty(exports, "version", ({ - enumerable: true, - get: function () { - return _version.default; - } -})); -Object.defineProperty(exports, "validate", ({ - enumerable: true, - get: function () { - return _validate.default; - } -})); -Object.defineProperty(exports, "stringify", ({ - enumerable: true, - get: function () { - return _stringify.default; - } -})); -Object.defineProperty(exports, "parse", ({ - enumerable: true, - get: function () { - return _parse.default; - } -})); - -var _v = _interopRequireDefault(__nccwpck_require__(78628)); - -var _v2 = _interopRequireDefault(__nccwpck_require__(86409)); - -var _v3 = _interopRequireDefault(__nccwpck_require__(85122)); - -var _v4 = _interopRequireDefault(__nccwpck_require__(79120)); - -var _nil = _interopRequireDefault(__nccwpck_require__(25332)); - -var _version = _interopRequireDefault(__nccwpck_require__(81595)); - -var _validate = _interopRequireDefault(__nccwpck_require__(66900)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); - -var _parse = _interopRequireDefault(__nccwpck_require__(62746)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/***/ }), - -/***/ 4569: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function md5(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('md5').update(bytes).digest(); -} - -var _default = md5; -exports["default"] = _default; - -/***/ }), - -/***/ 25332: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = '00000000-0000-0000-0000-000000000000'; -exports["default"] = _default; - -/***/ }), - -/***/ 62746: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(66900)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function parse(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - let v; - const arr = new Uint8Array(16); // Parse ########-....-....-....-............ - - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; // Parse ........-####-....-....-............ - - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; // Parse ........-....-####-....-............ - - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; // Parse ........-....-....-####-............ - - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} - -var _default = parse; -exports["default"] = _default; - -/***/ }), - -/***/ 40814: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; -exports["default"] = _default; - -/***/ }), - -/***/ 50807: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = rng; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate - -let poolPtr = rnds8Pool.length; - -function rng() { - if (poolPtr > rnds8Pool.length - 16) { - _crypto.default.randomFillSync(rnds8Pool); - - poolPtr = 0; - } - - return rnds8Pool.slice(poolPtr, poolPtr += 16); -} - -/***/ }), - -/***/ 85274: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function sha1(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('sha1').update(bytes).digest(); -} - -var _default = sha1; -exports["default"] = _default; - -/***/ }), - -/***/ 18950: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(66900)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -const byteToHex = []; - -for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).substr(1)); -} - -function stringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - - if (!(0, _validate.default)(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - - return uuid; -} - -var _default = stringify; -exports["default"] = _default; - -/***/ }), - -/***/ 78628: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(50807)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html -let _nodeId; - -let _clockseq; // Previous uuid creation time - - -let _lastMSecs = 0; -let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details - -function v1(options, buf, offset) { - let i = buf && offset || 0; - const b = buf || new Array(16); - options = options || {}; - let node = options.node || _nodeId; - let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - - if (node == null || clockseq == null) { - const seedBytes = options.random || (options.rng || _rng.default)(); - - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - } - - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - } - } // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - - - let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - - let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) - - const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression - - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - - - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } // Per 4.2.1.2 Throw error if too many uuids are requested - - - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - - msecs += 12219292800000; // `time_low` - - const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; // `time_mid` - - const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; // `time_high_and_version` - - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - - b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - - b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` - - b[i++] = clockseq & 0xff; // `node` - - for (let n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf || (0, _stringify.default)(b); -} - -var _default = v1; -exports["default"] = _default; - -/***/ }), - -/***/ 86409: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(65998)); - -var _md = _interopRequireDefault(__nccwpck_require__(4569)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v3 = (0, _v.default)('v3', 0x30, _md.default); -var _default = v3; -exports["default"] = _default; - -/***/ }), - -/***/ 65998: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = _default; -exports.URL = exports.DNS = void 0; - -var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); - -var _parse = _interopRequireDefault(__nccwpck_require__(62746)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - const bytes = []; - - for (let i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - - return bytes; -} - -const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -exports.DNS = DNS; -const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -exports.URL = URL; - -function _default(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - if (typeof value === 'string') { - value = stringToBytes(value); - } - - if (typeof namespace === 'string') { - namespace = (0, _parse.default)(namespace); - } - - if (namespace.length !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - - - let bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - - return buf; - } - - return (0, _stringify.default)(bytes); - } // Function#name is not settable on some platforms (#270) - - - try { - generateUUID.name = name; // eslint-disable-next-line no-empty - } catch (err) {} // For CommonJS default export support - - - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} - -/***/ }), - -/***/ 85122: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(50807)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(18950)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function v4(options, buf, offset) { - options = options || {}; - - const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - - - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - - return buf; - } - - return (0, _stringify.default)(rnds); -} - -var _default = v4; -exports["default"] = _default; - -/***/ }), - -/***/ 79120: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(65998)); - -var _sha = _interopRequireDefault(__nccwpck_require__(85274)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v5 = (0, _v.default)('v5', 0x50, _sha.default); -var _default = v5; -exports["default"] = _default; - -/***/ }), - -/***/ 66900: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _regex = _interopRequireDefault(__nccwpck_require__(40814)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function validate(uuid) { - return typeof uuid === 'string' && _regex.default.test(uuid); -} - -var _default = validate; -exports["default"] = _default; - -/***/ }), - -/***/ 81595: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(66900)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function version(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - return parseInt(uuid.substr(14, 1), 16); -} - -var _default = version; -exports["default"] = _default; - /***/ }), /***/ 69042: @@ -121376,7 +121376,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }; Object.defineProperty(exports, "__esModule", ({ value: true })); const core = __importStar(__nccwpck_require__(42186)); -const artifact_1 = __nccwpck_require__(99860); +const artifact_1 = __nccwpck_require__(15545); const search_1 = __nccwpck_require__(13930); const input_helper_1 = __nccwpck_require__(46455); const constants_1 = __nccwpck_require__(69042); @@ -121406,9 +121406,6 @@ function run() { const s = searchResult.filesToUpload.length === 1 ? '' : 's'; core.info(`With the provided path, there will be ${searchResult.filesToUpload.length} file${s} uploaded`); core.debug(`Root artifact directory is ${searchResult.rootDirectory}`); - if (searchResult.filesToUpload.length > 10000) { - core.warning(`There are over 10,000 files in this artifact, consider creating an archive before upload to improve the upload performance.`); - } const artifactClient = (0, artifact_1.create)(); const options = {}; if (inputs.retentionDays) { @@ -121419,7 +121416,8 @@ function run() { core.setFailed(`An error was encountered when uploading ${inputs.artifactName}.`); } else { - core.info(`Artifact ${inputs.artifactName} has been successfully uploaded! Final size is ${uploadResponse.size} bytes. Artifact ID is ${uploadResponse.id}}`); + core.info(`Artifact ${inputs.artifactName} has been successfully uploaded! Final size is ${uploadResponse.size} bytes. Artifact ID is ${uploadResponse.id}`); + core.setOutput('artifact-id', uploadResponse.id); } } } @@ -121601,7 +121599,7 @@ module.exports = require("zlib"); /***/ }), -/***/ 93991: +/***/ 25936: /***/ ((module) => { "use strict"; @@ -121609,7 +121607,7 @@ module.exports = JSON.parse('[["8740","䏰䰲䘃䖦䕸𧉧䵷䖳𧲱䳢𧳅㮕 /***/ }), -/***/ 85497: +/***/ 64934: /***/ ((module) => { "use strict"; @@ -121617,7 +121615,7 @@ module.exports = JSON.parse('[["0","\\u0000",127,"€"],["8140","丂丄丅丆丏 /***/ }), -/***/ 99519: +/***/ 22885: /***/ ((module) => { "use strict"; @@ -121625,7 +121623,7 @@ module.exports = JSON.parse('[["0","\\u0000",127],["8141","갂갃갅갆갋",4," /***/ }), -/***/ 31745: +/***/ 15154: /***/ ((module) => { "use strict"; @@ -121633,7 +121631,7 @@ module.exports = JSON.parse('[["0","\\u0000",127],["a140","　，、。．‧； /***/ }), -/***/ 64688: +/***/ 78419: /***/ ((module) => { "use strict"; @@ -121641,7 +121639,7 @@ module.exports = JSON.parse('[["0","\\u0000",127],["8ea1","｡",62],["a1a1","　 /***/ }), -/***/ 19331: +/***/ 39498: /***/ ((module) => { "use strict"; @@ -121649,7 +121647,7 @@ module.exports = JSON.parse('{"uChars":[128,165,169,178,184,216,226,235,238,244, /***/ }), -/***/ 49670: +/***/ 2191: /***/ ((module) => { "use strict"; @@ -121657,7 +121655,7 @@ module.exports = JSON.parse('[["a140","",62],["a180","",32],["a240","", /***/ }), -/***/ 48064: +/***/ 79561: /***/ ((module) => { "use strict"; @@ -121665,7 +121663,7 @@ module.exports = JSON.parse('[["0","\\u0000",128],["a1","｡",62],["8140","　 /***/ }), -/***/ 2131: +/***/ 22913: /***/ ((module) => { "use strict"; @@ -121673,7 +121671,7 @@ module.exports = JSON.parse('{"application/1d-interleaved-parityfec":{"source":" /***/ }), -/***/ 99022: +/***/ 68865: /***/ ((module) => { "use strict"; @@ -121681,7 +121679,7 @@ module.exports = JSON.parse('[[[0,44],"disallowed_STD3_valid"],[[45,46],"valid"] /***/ }), -/***/ 9303: +/***/ 71896: /***/ ((module) => { "use strict"; diff --git a/src/upload-artifact.ts b/src/upload-artifact.ts index 2c1874a..8059f54 100644 --- a/src/upload-artifact.ts +++ b/src/upload-artifact.ts @@ -37,12 +37,6 @@ async function run(): Promise { ) core.debug(`Root artifact directory is ${searchResult.rootDirectory}`) - if (searchResult.filesToUpload.length > 10000) { - core.warning( - `There are over 10,000 files in this artifact, consider creating an archive before upload to improve the upload performance.` - ) - } - const artifactClient = create() const options: UploadOptions = {} if (inputs.retentionDays) { @@ -62,8 +56,9 @@ async function run(): Promise { ) } else { core.info( - `Artifact ${inputs.artifactName} has been successfully uploaded! Final size is ${uploadResponse.size} bytes. Artifact ID is ${uploadResponse.id}}` + `Artifact ${inputs.artifactName} has been successfully uploaded! Final size is ${uploadResponse.size} bytes. Artifact ID is ${uploadResponse.id}` ) + core.setOutput('artifact-id', uploadResponse.id) } } } catch (error) {