diff --git a/dist/index.js b/dist/index.js index 31f72a5..698c700 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,7 +1,7 @@ /******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ -/***/ 9777: +/***/ 2183: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -28,7 +28,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__(2037)); -const utils_1 = __nccwpck_require__(9855); +const utils_1 = __nccwpck_require__(9816); /** * Commands * @@ -100,7 +100,7 @@ function escapeProperty(s) { /***/ }), -/***/ 4181: +/***/ 7481: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -135,12 +135,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__(9777); -const file_command_1 = __nccwpck_require__(3679); -const utils_1 = __nccwpck_require__(9855); +const command_1 = __nccwpck_require__(2183); +const file_command_1 = __nccwpck_require__(162); +const utils_1 = __nccwpck_require__(9816); const os = __importStar(__nccwpck_require__(2037)); const path = __importStar(__nccwpck_require__(1017)); -const oidc_utils_1 = __nccwpck_require__(6266); +const oidc_utils_1 = __nccwpck_require__(3177); /** * The code to exit an action */ @@ -169,13 +169,9 @@ function exportVariable(name, val) { process.env[name] = convertedVal; const filePath = process.env['GITHUB_ENV'] || ''; if (filePath) { - const delimiter = '_GitHubActionsFileCommandDelimeter_'; - const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`; - file_command_1.issueCommand('ENV', commandValue); - } - else { - command_1.issueCommand('set-env', { name }, convertedVal); + return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); } + command_1.issueCommand('set-env', { name }, convertedVal); } exports.exportVariable = exportVariable; /** @@ -193,7 +189,7 @@ exports.setSecret = setSecret; function addPath(inputPath) { const filePath = process.env['GITHUB_PATH'] || ''; if (filePath) { - file_command_1.issueCommand('PATH', inputPath); + file_command_1.issueFileCommand('PATH', inputPath); } else { command_1.issueCommand('add-path', {}, inputPath); @@ -233,7 +229,10 @@ function getMultilineInput(name, options) { const inputs = getInput(name, options) .split('\n') .filter(x => x !== ''); - return inputs; + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map(input => input.trim()); } exports.getMultilineInput = getMultilineInput; /** @@ -266,8 +265,12 @@ exports.getBooleanInput = getBooleanInput; */ // 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 }, value); + command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); } exports.setOutput = setOutput; /** @@ -396,7 +399,11 @@ exports.group = group; */ // eslint-disable-next-line @typescript-eslint/no-explicit-any function saveState(name, value) { - command_1.issueCommand('save-state', { 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; /** @@ -415,11 +422,28 @@ function getIDToken(aud) { }); } exports.getIDToken = getIDToken; +/** + * Summary exports + */ +var summary_1 = __nccwpck_require__(4842); +Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); +/** + * @deprecated use core.summary + */ +var summary_2 = __nccwpck_require__(4842); +Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); +/** + * Path exports + */ +var path_utils_1 = __nccwpck_require__(2773); +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 /***/ }), -/***/ 3679: +/***/ 162: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -445,13 +469,14 @@ var __importStar = (this && this.__importStar) || function (mod) { return result; }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.issueCommand = void 0; +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__(7147)); const os = __importStar(__nccwpck_require__(2037)); -const utils_1 = __nccwpck_require__(9855); -function issueCommand(command, message) { +const uuid_1 = __nccwpck_require__(4350); +const utils_1 = __nccwpck_require__(9816); +function issueFileCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; if (!filePath) { throw new Error(`Unable to find environment variable for file command ${command}`); @@ -463,12 +488,27 @@ function issueCommand(command, message) { encoding: 'utf8' }); } -exports.issueCommand = issueCommand; +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 /***/ }), -/***/ 6266: +/***/ 3177: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; @@ -484,9 +524,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__(3068); -const auth_1 = __nccwpck_require__(1351); -const core_1 = __nccwpck_require__(4181); +const http_client_1 = __nccwpck_require__(457); +const auth_1 = __nccwpck_require__(2072); +const core_1 = __nccwpck_require__(7481); class OidcClient { static createHttpClient(allowRetry = true, maxRetry = 10) { const requestOptions = { @@ -552,7 +592,362 @@ exports.OidcClient = OidcClient; /***/ }), -/***/ 9855: +/***/ 2773: +/***/ (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__(1017)); +/** + * 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 + +/***/ }), + +/***/ 4842: +/***/ (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__(2037); +const fs_1 = __nccwpck_require__(7147); +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 + +/***/ }), + +/***/ 9816: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -599,28 +994,687 @@ exports.toCommandProperties = toCommandProperties; /***/ }), -/***/ 1351: +/***/ 4350: +/***/ ((__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__(942)); + +var _v2 = _interopRequireDefault(__nccwpck_require__(9341)); + +var _v3 = _interopRequireDefault(__nccwpck_require__(8571)); + +var _v4 = _interopRequireDefault(__nccwpck_require__(5203)); + +var _nil = _interopRequireDefault(__nccwpck_require__(833)); + +var _version = _interopRequireDefault(__nccwpck_require__(8809)); + +var _validate = _interopRequireDefault(__nccwpck_require__(6493)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(2294)); + +var _parse = _interopRequireDefault(__nccwpck_require__(6089)); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/***/ }), + +/***/ 5: +/***/ ((__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; + +/***/ }), + +/***/ 833: +/***/ ((__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; + +/***/ }), + +/***/ 6089: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6493)); + +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; + +/***/ }), + +/***/ 9742: /***/ ((__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; + +/***/ }), + +/***/ 6019: +/***/ ((__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); +} + +/***/ }), + +/***/ 9079: +/***/ ((__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; + +/***/ }), + +/***/ 2294: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6493)); + +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; + +/***/ }), + +/***/ 942: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(6019)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(2294)); + +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; + +/***/ }), + +/***/ 9341: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5695)); + +var _md = _interopRequireDefault(__nccwpck_require__(5)); + +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; + +/***/ }), + +/***/ 5695: +/***/ ((__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__(2294)); + +var _parse = _interopRequireDefault(__nccwpck_require__(6089)); + +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; +} + +/***/ }), + +/***/ 8571: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _rng = _interopRequireDefault(__nccwpck_require__(6019)); + +var _stringify = _interopRequireDefault(__nccwpck_require__(2294)); + +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; + +/***/ }), + +/***/ 5203: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _v = _interopRequireDefault(__nccwpck_require__(5695)); + +var _sha = _interopRequireDefault(__nccwpck_require__(9079)); + +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; + +/***/ }), + +/***/ 6493: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(__nccwpck_require__(9742)); + +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; + +/***/ }), + +/***/ 8809: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; + +var _validate = _interopRequireDefault(__nccwpck_require__(6493)); + +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; + +/***/ }), + +/***/ 2072: +/***/ (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) { - options.headers['Authorization'] = - 'Basic ' + - Buffer.from(this.username + ':' + this.password).toString('base64'); + 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(response) { + canHandleAuthentication() { return false; } - handleAuthentication(httpClient, requestInfo, objs) { - return null; + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); } } exports.BasicCredentialHandler = BasicCredentialHandler; @@ -631,14 +1685,19 @@ class BearerCredentialHandler { // currently implements pre-authorization // TODO: support preAuth = false where it hooks on 401 prepareRequest(options) { - options.headers['Authorization'] = 'Bearer ' + this.token; + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Bearer ${this.token}`; } // This handler cannot handle 401 - canHandleAuthentication(response) { + canHandleAuthentication() { return false; } - handleAuthentication(httpClient, requestInfo, objs) { - return null; + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); } } exports.BearerCredentialHandler = BearerCredentialHandler; @@ -649,32 +1708,66 @@ class PersonalAccessTokenCredentialHandler { // currently implements pre-authorization // TODO: support preAuth = false where it hooks on 401 prepareRequest(options) { - options.headers['Authorization'] = - 'Basic ' + Buffer.from('PAT:' + this.token).toString('base64'); + 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(response) { + canHandleAuthentication() { return false; } - handleAuthentication(httpClient, requestInfo, objs) { - return null; + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); } } exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; - +//# sourceMappingURL=auth.js.map /***/ }), -/***/ 3068: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +/***/ 457: +/***/ (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 })); -const http = __nccwpck_require__(3685); -const https = __nccwpck_require__(5687); -const pm = __nccwpck_require__(9859); -let tunnel; +exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; +const http = __importStar(__nccwpck_require__(3685)); +const https = __importStar(__nccwpck_require__(5687)); +const pm = __importStar(__nccwpck_require__(9110)); +const tunnel = __importStar(__nccwpck_require__(5572)); var HttpCodes; (function (HttpCodes) { HttpCodes[HttpCodes["OK"] = 200] = "OK"; @@ -719,7 +1812,7 @@ var MediaTypes; * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com */ function getProxyUrl(serverUrl) { - let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); return proxyUrl ? proxyUrl.href : ''; } exports.getProxyUrl = getProxyUrl; @@ -752,20 +1845,22 @@ class HttpClientResponse { this.message = message; } readBody() { - return new Promise(async (resolve, reject) => { - let output = Buffer.alloc(0); - this.message.on('data', (chunk) => { - output = Buffer.concat([output, chunk]); - }); - this.message.on('end', () => { - resolve(output.toString()); - }); + 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) { - let parsedUrl = new URL(requestUrl); + const parsedUrl = new URL(requestUrl); return parsedUrl.protocol === 'https:'; } exports.isHttps = isHttps; @@ -808,141 +1903,169 @@ class HttpClient { } } options(requestUrl, additionalHeaders) { - return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + }); } get(requestUrl, additionalHeaders) { - return this.request('GET', requestUrl, null, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + }); } del(requestUrl, additionalHeaders) { - return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + }); } post(requestUrl, data, additionalHeaders) { - return this.request('POST', requestUrl, data, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + }); } patch(requestUrl, data, additionalHeaders) { - return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + }); } put(requestUrl, data, additionalHeaders) { - return this.request('PUT', requestUrl, data, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + }); } head(requestUrl, additionalHeaders) { - return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + return __awaiter(this, void 0, void 0, function* () { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + }); } sendStream(verb, requestUrl, stream, additionalHeaders) { - return this.request(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 */ - async getJson(requestUrl, additionalHeaders = {}) { - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - let res = await this.get(requestUrl, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async postJson(requestUrl, obj, additionalHeaders = {}) { - let 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); - let res = await this.post(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async putJson(requestUrl, obj, additionalHeaders = {}) { - let 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); - let res = await this.put(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - } - async patchJson(requestUrl, obj, additionalHeaders = {}) { - let 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); - let res = await this.patch(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); + 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 */ - async request(verb, requestUrl, data, headers) { - if (this._disposed) { - throw new Error('Client has already been disposed.'); - } - let parsedUrl = new URL(requestUrl); - let info = this._prepareRequest(verb, parsedUrl, headers); - // Only perform retries on reads since writes may not be idempotent. - let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 - ? this._maxRetries + 1 - : 1; - let numTries = 0; - let response; - while (numTries < maxTries) { - response = await this.requestRaw(info, data); - // Check if it's an authentication challenge - if (response && - response.message && - response.message.statusCode === HttpCodes.Unauthorized) { - let authenticationHandler; - for (let i = 0; i < this.handlers.length; i++) { - if (this.handlers[i].canHandleAuthentication(response)) { - authenticationHandler = this.handlers[i]; - break; + 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; } } - if (authenticationHandler) { - return authenticationHandler.handleAuthentication(this, info, data); + 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--; } - else { - // We have received an unauthorized response but have no handlers to handle it. - // Let the response return to the caller. + if (!response.message.statusCode || + !HttpResponseRetryCodes.includes(response.message.statusCode)) { + // If not a retry code, return immediately instead of retrying return response; } - } - let redirectsRemaining = this._maxRedirects; - while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && - this._allowRedirects && - redirectsRemaining > 0) { - const redirectUrl = response.message.headers['location']; - if (!redirectUrl) { - // if there's no location to redirect to, we won't - break; - } - let 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. - await response.readBody(); - // strip authorization header if redirected to a different hostname - if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { - for (let header in headers) { - // header names are case insensitive - if (header.toLowerCase() === 'authorization') { - delete headers[header]; - } - } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); } - // let's make the request with the new redirectUrl - info = this._prepareRequest(verb, parsedRedirectUrl, headers); - response = await this.requestRaw(info, data); - redirectsRemaining--; - } - if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { - // If not a retry code, return immediately instead of retrying - return response; - } - numTries += 1; - if (numTries < maxTries) { - await response.readBody(); - await this._performExponentialBackoff(numTries); - } - } - return response; + } while (numTries < maxTries); + return response; + }); } /** * Needs to be called if keepAlive is set to true in request options. @@ -959,14 +2082,22 @@ class HttpClient { * @param data */ requestRaw(info, data) { - return new Promise((resolve, reject) => { - let callbackForResult = function (err, res) { - if (err) { - reject(err); + 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); + } } - resolve(res); - }; - this.requestRawWithCallback(info, data, callbackForResult); + this.requestRawWithCallback(info, data, callbackForResult); + }); }); } /** @@ -976,21 +2107,24 @@ class HttpClient { * @param onResult */ requestRawWithCallback(info, data, onResult) { - let socket; if (typeof data === 'string') { + if (!info.options.headers) { + info.options.headers = {}; + } info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); } let callbackCalled = false; - let handleResult = (err, res) => { + function handleResult(err, res) { if (!callbackCalled) { callbackCalled = true; onResult(err, res); } - }; - let req = info.httpModule.request(info.options, (msg) => { - let res = new HttpClientResponse(msg); - handleResult(null, 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; }); @@ -999,12 +2133,12 @@ class HttpClient { if (socket) { socket.end(); } - handleResult(new Error('Request timeout: ' + info.options.path), null); + handleResult(new Error(`Request timeout: ${info.options.path}`)); }); req.on('error', function (err) { // err has statusCode property // res should have headers - handleResult(err, null); + handleResult(err); }); if (data && typeof data === 'string') { req.write(data, 'utf8'); @@ -1025,7 +2159,7 @@ class HttpClient { * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com */ getAgent(serverUrl) { - let parsedUrl = new URL(serverUrl); + const parsedUrl = new URL(serverUrl); return this._getAgent(parsedUrl); } _prepareRequest(method, requestUrl, headers) { @@ -1049,21 +2183,19 @@ class HttpClient { info.options.agent = this._getAgent(info.parsedUrl); // gives handlers an opportunity to participate if (this.handlers) { - this.handlers.forEach(handler => { + for (const handler of this.handlers) { handler.prepareRequest(info.options); - }); + } } return info; } _mergeHeaders(headers) { - const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); if (this.requestOptions && this.requestOptions.headers) { - return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); } return lowercaseKeys(headers || {}); } _getExistingOrDefaultHeader(additionalHeaders, header, _default) { - const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); let clientHeader; if (this.requestOptions && this.requestOptions.headers) { clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; @@ -1072,8 +2204,8 @@ class HttpClient { } _getAgent(parsedUrl) { let agent; - let proxyUrl = pm.getProxyUrl(parsedUrl); - let useProxy = proxyUrl && proxyUrl.hostname; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; if (this._keepAlive && useProxy) { agent = this._proxyAgent; } @@ -1081,29 +2213,22 @@ class HttpClient { agent = this._agent; } // if agent is already assigned use that agent. - if (!!agent) { + if (agent) { return agent; } const usingSsl = parsedUrl.protocol === 'https:'; let maxSockets = 100; - if (!!this.requestOptions) { + if (this.requestOptions) { maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; } - if (useProxy) { - // If using proxy, need tunnel - if (!tunnel) { - tunnel = __nccwpck_require__(586); - } + // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. + if (proxyUrl && proxyUrl.hostname) { const agentOptions = { - maxSockets: maxSockets, + maxSockets, keepAlive: this._keepAlive, - proxy: { - ...((proxyUrl.username || proxyUrl.password) && { - proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` - }), - host: proxyUrl.hostname, - port: proxyUrl.port - } + 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:'; @@ -1118,7 +2243,7 @@ class HttpClient { } // 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: maxSockets }; + const options = { keepAlive: this._keepAlive, maxSockets }; agent = usingSsl ? new https.Agent(options) : new http.Agent(options); this._agent = agent; } @@ -1137,109 +2262,121 @@ class HttpClient { return agent; } _performExponentialBackoff(retryNumber) { - retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); - const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); - return new Promise(resolve => setTimeout(() => resolve(), ms)); - } - static dateTimeDeserializer(key, value) { - if (typeof value === 'string') { - let a = new Date(value); - if (!isNaN(a.valueOf())) { - return a; - } - } - return value; + 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)); + }); } - async _processResponse(res, options) { - return new Promise(async (resolve, reject) => { - const statusCode = res.message.statusCode; - const response = { - statusCode: statusCode, - result: null, - headers: {} - }; - // not found leads to null obj returned - if (statusCode == HttpCodes.NotFound) { - resolve(response); - } - let obj; - let contents; - // get the result from the body - try { - contents = await res.readBody(); - if (contents && contents.length > 0) { - if (options && options.deserializeDates) { - obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + _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; + } } - else { - obj = JSON.parse(contents); + 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.result = obj; + response.headers = res.message.headers; } - 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; + catch (err) { + // Invalid resource (contents not json); leaving result obj null } - else if (contents && contents.length > 0) { - // it may be the case that the exception is in the body message as string - msg = contents; + // 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 { - msg = 'Failed request: (' + statusCode + ')'; + resolve(response); } - let 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 /***/ }), -/***/ 9859: +/***/ 9110: /***/ ((__unused_webpack_module, exports) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.checkBypass = exports.getProxyUrl = void 0; function getProxyUrl(reqUrl) { - let usingSsl = reqUrl.protocol === 'https:'; - let proxyUrl; + const usingSsl = reqUrl.protocol === 'https:'; if (checkBypass(reqUrl)) { - return proxyUrl; + return undefined; } - let proxyVar; - if (usingSsl) { - proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; + 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 { - proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; - } - if (proxyVar) { - proxyUrl = new URL(proxyVar); + return undefined; } - return proxyUrl; } exports.getProxyUrl = getProxyUrl; function checkBypass(reqUrl) { if (!reqUrl.hostname) { return false; } - let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; if (!noProxy) { return false; } @@ -1255,27 +2392,38 @@ function checkBypass(reqUrl) { reqPort = 443; } // Format the request hostname and hostname with port - let upperReqHosts = [reqUrl.hostname.toUpperCase()]; + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; if (typeof reqPort === 'number') { upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); } // Compare request host against noproxy - for (let upperNoProxyItem of noProxy + for (const upperNoProxyItem of noProxy .split(',') .map(x => x.trim().toUpperCase()) .filter(x => x)) { - if (upperReqHosts.some(x => x === upperNoProxyItem)) { + if (upperNoProxyItem === '*' || + upperReqHosts.some(x => x === upperNoProxyItem || + x.endsWith(`.${upperNoProxyItem}`) || + (upperNoProxyItem.startsWith('.') && + x.endsWith(`${upperNoProxyItem}`)))) { return true; } } return false; } exports.checkBypass = checkBypass; - +function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return (hostLower === 'localhost' || + hostLower.startsWith('127.') || + hostLower.startsWith('[::1]') || + hostLower.startsWith('[0:0:0:0:0:0:0:1]')); +} +//# sourceMappingURL=proxy.js.map /***/ }), -/***/ 27: +/***/ 1103: /***/ ((module) => { function _interopRequireDefault(obj) { @@ -1288,19 +2436,19 @@ module.exports = _interopRequireDefault, module.exports.__esModule = true, modul /***/ }), -/***/ 8401: +/***/ 7034: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var CombinedStream = __nccwpck_require__(2336); +var CombinedStream = __nccwpck_require__(4592); var util = __nccwpck_require__(3837); var path = __nccwpck_require__(1017); var http = __nccwpck_require__(3685); var https = __nccwpck_require__(5687); var parseUrl = (__nccwpck_require__(7310).parse); var fs = __nccwpck_require__(7147); -var mime = __nccwpck_require__(2720); -var asynckit = __nccwpck_require__(9327); -var populate = __nccwpck_require__(8506); +var mime = __nccwpck_require__(3491); +var asynckit = __nccwpck_require__(2899); +var populate = __nccwpck_require__(6053); // Public API module.exports = FormData; @@ -1820,7 +2968,7 @@ FormData.prototype.toString = function () { /***/ }), -/***/ 8506: +/***/ 6053: /***/ ((module) => { // populates missing values @@ -1837,7 +2985,7 @@ module.exports = function(dst, src) { /***/ }), -/***/ 6291: +/***/ 8952: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -1849,7 +2997,7 @@ var net = __nccwpck_require__(1808) , https = __nccwpck_require__(5687) , events = __nccwpck_require__(2361) , util = __nccwpck_require__(3837) - , Buffer = (__nccwpck_require__(3925).Buffer) + , Buffer = (__nccwpck_require__(9011).Buffer) ; exports.httpOverHttp = httpOverHttp @@ -2119,21 +3267,21 @@ exports.debug = debug // for test /***/ }), -/***/ 2235: +/***/ 3718: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var compileSchema = __nccwpck_require__(3665) - , resolve = __nccwpck_require__(5248) - , Cache = __nccwpck_require__(4692) - , SchemaObject = __nccwpck_require__(2239) - , stableStringify = __nccwpck_require__(2181) - , formats = __nccwpck_require__(5016) - , rules = __nccwpck_require__(8093) - , $dataMetaSchema = __nccwpck_require__(8639) - , util = __nccwpck_require__(8653); +var compileSchema = __nccwpck_require__(7592) + , resolve = __nccwpck_require__(6625) + , Cache = __nccwpck_require__(8647) + , SchemaObject = __nccwpck_require__(1353) + , stableStringify = __nccwpck_require__(428) + , formats = __nccwpck_require__(562) + , rules = __nccwpck_require__(7993) + , $dataMetaSchema = __nccwpck_require__(7039) + , util = __nccwpck_require__(2803); module.exports = Ajv; @@ -2150,14 +3298,14 @@ Ajv.prototype.errorsText = errorsText; Ajv.prototype._addSchema = _addSchema; Ajv.prototype._compile = _compile; -Ajv.prototype.compileAsync = __nccwpck_require__(5054); -var customKeyword = __nccwpck_require__(7279); +Ajv.prototype.compileAsync = __nccwpck_require__(5014); +var customKeyword = __nccwpck_require__(8285); Ajv.prototype.addKeyword = customKeyword.add; Ajv.prototype.getKeyword = customKeyword.get; Ajv.prototype.removeKeyword = customKeyword.remove; Ajv.prototype.validateKeyword = customKeyword.validate; -var errorClasses = __nccwpck_require__(7209); +var errorClasses = __nccwpck_require__(5457); Ajv.ValidationError = errorClasses.Validation; Ajv.MissingRefError = errorClasses.MissingRef; Ajv.$dataMetaSchema = $dataMetaSchema; @@ -2633,7 +3781,7 @@ function noop() {} /***/ }), -/***/ 4692: +/***/ 8647: /***/ ((module) => { "use strict"; @@ -2667,13 +3815,13 @@ Cache.prototype.clear = function Cache_clear() { /***/ }), -/***/ 5054: +/***/ 5014: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var MissingRefError = (__nccwpck_require__(7209).MissingRef); +var MissingRefError = (__nccwpck_require__(5457).MissingRef); module.exports = compileAsync; @@ -2765,13 +3913,13 @@ function compileAsync(schema, meta, callback) { /***/ }), -/***/ 7209: +/***/ 5457: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var resolve = __nccwpck_require__(5248); +var resolve = __nccwpck_require__(6625); module.exports = { Validation: errorSubclass(ValidationError), @@ -2807,13 +3955,13 @@ function errorSubclass(Subclass) { /***/ }), -/***/ 5016: +/***/ 562: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(8653); +var util = __nccwpck_require__(2803); var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; var DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31]; @@ -2957,25 +4105,25 @@ function regex(str) { /***/ }), -/***/ 3665: +/***/ 7592: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var resolve = __nccwpck_require__(5248) - , util = __nccwpck_require__(8653) - , errorClasses = __nccwpck_require__(7209) - , stableStringify = __nccwpck_require__(2181); +var resolve = __nccwpck_require__(6625) + , util = __nccwpck_require__(2803) + , errorClasses = __nccwpck_require__(5457) + , stableStringify = __nccwpck_require__(428); -var validateGenerator = __nccwpck_require__(4715); +var validateGenerator = __nccwpck_require__(750); /** * Functions below are used inside compiled validations function */ var ucs2length = util.ucs2length; -var equal = __nccwpck_require__(7120); +var equal = __nccwpck_require__(5066); // this error is thrown by async schemas to return validation errors via exception var ValidationError = errorClasses.Validation; @@ -3352,17 +4500,17 @@ function vars(arr, statement) { /***/ }), -/***/ 5248: +/***/ 6625: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var URI = __nccwpck_require__(5165) - , equal = __nccwpck_require__(7120) - , util = __nccwpck_require__(8653) - , SchemaObject = __nccwpck_require__(2239) - , traverse = __nccwpck_require__(6899); +var URI = __nccwpck_require__(374) + , equal = __nccwpck_require__(5066) + , util = __nccwpck_require__(2803) + , SchemaObject = __nccwpck_require__(1353) + , traverse = __nccwpck_require__(7155); module.exports = resolve; @@ -3630,14 +4778,14 @@ function resolveIds(schema) { /***/ }), -/***/ 8093: +/***/ 7993: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var ruleModules = __nccwpck_require__(719) - , toHash = (__nccwpck_require__(8653).toHash); +var ruleModules = __nccwpck_require__(7269) + , toHash = (__nccwpck_require__(2803).toHash); module.exports = function rules() { var RULES = [ @@ -3704,13 +4852,13 @@ module.exports = function rules() { /***/ }), -/***/ 2239: +/***/ 1353: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(8653); +var util = __nccwpck_require__(2803); module.exports = SchemaObject; @@ -3721,7 +4869,7 @@ function SchemaObject(obj) { /***/ }), -/***/ 1788: +/***/ 3823: /***/ ((module) => { "use strict"; @@ -3749,7 +4897,7 @@ module.exports = function ucs2length(str) { /***/ }), -/***/ 8653: +/***/ 2803: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -3764,8 +4912,8 @@ module.exports = { toHash: toHash, getProperty: getProperty, escapeQuotes: escapeQuotes, - equal: __nccwpck_require__(7120), - ucs2length: __nccwpck_require__(1788), + equal: __nccwpck_require__(5066), + ucs2length: __nccwpck_require__(3823), varOccurences: varOccurences, varReplace: varReplace, schemaHasRules: schemaHasRules, @@ -3996,7 +5144,7 @@ function unescapeJsonPointer(str) { /***/ }), -/***/ 8639: +/***/ 7039: /***/ ((module) => { "use strict"; @@ -4053,7 +5201,7 @@ module.exports = function (metaSchema, keywordsJsonPointers) { /***/ }), -/***/ 1207: +/***/ 3707: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -4098,7 +5246,7 @@ module.exports = { /***/ }), -/***/ 6360: +/***/ 9683: /***/ ((module) => { "use strict"; @@ -4269,7 +5417,7 @@ module.exports = function generate__limit(it, $keyword, $ruleType) { /***/ }), -/***/ 9691: +/***/ 4729: /***/ ((module) => { "use strict"; @@ -4357,7 +5505,7 @@ module.exports = function generate__limitItems(it, $keyword, $ruleType) { /***/ }), -/***/ 6812: +/***/ 3299: /***/ ((module) => { "use strict"; @@ -4450,7 +5598,7 @@ module.exports = function generate__limitLength(it, $keyword, $ruleType) { /***/ }), -/***/ 7753: +/***/ 5924: /***/ ((module) => { "use strict"; @@ -4538,7 +5686,7 @@ module.exports = function generate__limitProperties(it, $keyword, $ruleType) { /***/ }), -/***/ 6685: +/***/ 3584: /***/ ((module) => { "use strict"; @@ -4588,7 +5736,7 @@ module.exports = function generate_allOf(it, $keyword, $ruleType) { /***/ }), -/***/ 9683: +/***/ 8017: /***/ ((module) => { "use strict"; @@ -4669,7 +5817,7 @@ module.exports = function generate_anyOf(it, $keyword, $ruleType) { /***/ }), -/***/ 9358: +/***/ 2403: /***/ ((module) => { "use strict"; @@ -4691,7 +5839,7 @@ module.exports = function generate_comment(it, $keyword, $ruleType) { /***/ }), -/***/ 8974: +/***/ 434: /***/ ((module) => { "use strict"; @@ -4755,7 +5903,7 @@ module.exports = function generate_const(it, $keyword, $ruleType) { /***/ }), -/***/ 1003: +/***/ 5712: /***/ ((module) => { "use strict"; @@ -4844,7 +5992,7 @@ module.exports = function generate_contains(it, $keyword, $ruleType) { /***/ }), -/***/ 7375: +/***/ 9994: /***/ ((module) => { "use strict"; @@ -5080,7 +6228,7 @@ module.exports = function generate_custom(it, $keyword, $ruleType) { /***/ }), -/***/ 4639: +/***/ 9834: /***/ ((module) => { "use strict"; @@ -5256,7 +6404,7 @@ module.exports = function generate_dependencies(it, $keyword, $ruleType) { /***/ }), -/***/ 85: +/***/ 6812: /***/ ((module) => { "use strict"; @@ -5330,7 +6478,7 @@ module.exports = function generate_enum(it, $keyword, $ruleType) { /***/ }), -/***/ 5097: +/***/ 9628: /***/ ((module) => { "use strict"; @@ -5488,7 +6636,7 @@ module.exports = function generate_format(it, $keyword, $ruleType) { /***/ }), -/***/ 3600: +/***/ 7092: /***/ ((module) => { "use strict"; @@ -5599,7 +6747,7 @@ module.exports = function generate_if(it, $keyword, $ruleType) { /***/ }), -/***/ 719: +/***/ 7269: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -5607,40 +6755,40 @@ module.exports = function generate_if(it, $keyword, $ruleType) { //all requires must be explicit because browserify won't work with dynamic requires module.exports = { - '$ref': __nccwpck_require__(2922), - allOf: __nccwpck_require__(6685), - anyOf: __nccwpck_require__(9683), - '$comment': __nccwpck_require__(9358), - const: __nccwpck_require__(8974), - contains: __nccwpck_require__(1003), - dependencies: __nccwpck_require__(4639), - 'enum': __nccwpck_require__(85), - format: __nccwpck_require__(5097), - 'if': __nccwpck_require__(3600), - items: __nccwpck_require__(1121), - maximum: __nccwpck_require__(6360), - minimum: __nccwpck_require__(6360), - maxItems: __nccwpck_require__(9691), - minItems: __nccwpck_require__(9691), - maxLength: __nccwpck_require__(6812), - minLength: __nccwpck_require__(6812), - maxProperties: __nccwpck_require__(7753), - minProperties: __nccwpck_require__(7753), - multipleOf: __nccwpck_require__(7582), - not: __nccwpck_require__(3751), - oneOf: __nccwpck_require__(9361), - pattern: __nccwpck_require__(4645), - properties: __nccwpck_require__(184), - propertyNames: __nccwpck_require__(2269), - required: __nccwpck_require__(7507), - uniqueItems: __nccwpck_require__(4858), - validate: __nccwpck_require__(4715) -}; - - -/***/ }), - -/***/ 1121: + '$ref': __nccwpck_require__(2866), + allOf: __nccwpck_require__(3584), + anyOf: __nccwpck_require__(8017), + '$comment': __nccwpck_require__(2403), + const: __nccwpck_require__(434), + contains: __nccwpck_require__(5712), + dependencies: __nccwpck_require__(9834), + 'enum': __nccwpck_require__(6812), + format: __nccwpck_require__(9628), + 'if': __nccwpck_require__(7092), + items: __nccwpck_require__(2291), + maximum: __nccwpck_require__(9683), + minimum: __nccwpck_require__(9683), + maxItems: __nccwpck_require__(4729), + minItems: __nccwpck_require__(4729), + maxLength: __nccwpck_require__(3299), + minLength: __nccwpck_require__(3299), + maxProperties: __nccwpck_require__(5924), + minProperties: __nccwpck_require__(5924), + multipleOf: __nccwpck_require__(5820), + not: __nccwpck_require__(7335), + oneOf: __nccwpck_require__(520), + pattern: __nccwpck_require__(5729), + properties: __nccwpck_require__(7275), + propertyNames: __nccwpck_require__(5275), + required: __nccwpck_require__(6446), + uniqueItems: __nccwpck_require__(5881), + validate: __nccwpck_require__(750) +}; + + +/***/ }), + +/***/ 2291: /***/ ((module) => { "use strict"; @@ -5788,7 +6936,7 @@ module.exports = function generate_items(it, $keyword, $ruleType) { /***/ }), -/***/ 7582: +/***/ 5820: /***/ ((module) => { "use strict"; @@ -5876,7 +7024,7 @@ module.exports = function generate_multipleOf(it, $keyword, $ruleType) { /***/ }), -/***/ 3751: +/***/ 7335: /***/ ((module) => { "use strict"; @@ -5968,7 +7116,7 @@ module.exports = function generate_not(it, $keyword, $ruleType) { /***/ }), -/***/ 9361: +/***/ 520: /***/ ((module) => { "use strict"; @@ -6049,7 +7197,7 @@ module.exports = function generate_oneOf(it, $keyword, $ruleType) { /***/ }), -/***/ 4645: +/***/ 5729: /***/ ((module) => { "use strict"; @@ -6132,7 +7280,7 @@ module.exports = function generate_pattern(it, $keyword, $ruleType) { /***/ }), -/***/ 184: +/***/ 7275: /***/ ((module) => { "use strict"; @@ -6475,7 +7623,7 @@ module.exports = function generate_properties(it, $keyword, $ruleType) { /***/ }), -/***/ 2269: +/***/ 5275: /***/ ((module) => { "use strict"; @@ -6564,7 +7712,7 @@ module.exports = function generate_propertyNames(it, $keyword, $ruleType) { /***/ }), -/***/ 2922: +/***/ 2866: /***/ ((module) => { "use strict"; @@ -6696,7 +7844,7 @@ module.exports = function generate_ref(it, $keyword, $ruleType) { /***/ }), -/***/ 7507: +/***/ 6446: /***/ ((module) => { "use strict"; @@ -6974,7 +8122,7 @@ module.exports = function generate_required(it, $keyword, $ruleType) { /***/ }), -/***/ 4858: +/***/ 5881: /***/ ((module) => { "use strict"; @@ -7068,7 +8216,7 @@ module.exports = function generate_uniqueItems(it, $keyword, $ruleType) { /***/ }), -/***/ 4715: +/***/ 750: /***/ ((module) => { "use strict"; @@ -7558,15 +8706,15 @@ module.exports = function generate_validate(it, $keyword, $ruleType) { /***/ }), -/***/ 7279: +/***/ 8285: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i; -var customRuleCode = __nccwpck_require__(7375); -var definitionSchema = __nccwpck_require__(1207); +var customRuleCode = __nccwpck_require__(9994); +var definitionSchema = __nccwpck_require__(3707); module.exports = { add: addKeyword, @@ -7712,7 +8860,7 @@ function validateKeyword(definition, throwError) { /***/ }), -/***/ 1202: +/***/ 5714: /***/ ((module) => { // Copyright 2011 Mark Cavage All rights reserved. @@ -7732,16 +8880,16 @@ module.exports = { /***/ }), -/***/ 4873: +/***/ 4992: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2011 Mark Cavage All rights reserved. -var errors = __nccwpck_require__(1202); -var types = __nccwpck_require__(6138); +var errors = __nccwpck_require__(5714); +var types = __nccwpck_require__(4047); -var Reader = __nccwpck_require__(6223); -var Writer = __nccwpck_require__(6884); +var Reader = __nccwpck_require__(4531); +var Writer = __nccwpck_require__(9471); // --- Exports @@ -7766,16 +8914,16 @@ for (var e in errors) { /***/ }), -/***/ 6223: +/***/ 4531: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2011 Mark Cavage All rights reserved. var assert = __nccwpck_require__(9491); -var Buffer = (__nccwpck_require__(5827).Buffer); +var Buffer = (__nccwpck_require__(4217).Buffer); -var ASN1 = __nccwpck_require__(6138); -var errors = __nccwpck_require__(1202); +var ASN1 = __nccwpck_require__(4047); +var errors = __nccwpck_require__(5714); // --- Globals @@ -8035,7 +9183,7 @@ module.exports = Reader; /***/ }), -/***/ 6138: +/***/ 4047: /***/ ((module) => { // Copyright 2011 Mark Cavage All rights reserved. @@ -8078,15 +9226,15 @@ module.exports = { /***/ }), -/***/ 6884: +/***/ 9471: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2011 Mark Cavage All rights reserved. var assert = __nccwpck_require__(9491); -var Buffer = (__nccwpck_require__(5827).Buffer); -var ASN1 = __nccwpck_require__(6138); -var errors = __nccwpck_require__(1202); +var Buffer = (__nccwpck_require__(4217).Buffer); +var ASN1 = __nccwpck_require__(4047); +var errors = __nccwpck_require__(5714); // --- Globals @@ -8402,7 +9550,7 @@ module.exports = Writer; /***/ }), -/***/ 687: +/***/ 2141: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2011 Mark Cavage All rights reserved. @@ -8410,7 +9558,7 @@ module.exports = Writer; // If you have no idea what ASN.1 or BER is, see this: // ftp://ftp.rsa.com/pub/pkcs/ascii/layman.asc -var Ber = __nccwpck_require__(4873); +var Ber = __nccwpck_require__(4992); @@ -8429,7 +9577,7 @@ module.exports = { /***/ }), -/***/ 6381: +/***/ 4500: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright (c) 2012, Mark Cavage. All rights reserved. @@ -8647,20 +9795,20 @@ module.exports = _setExports(process.env.NODE_NDEBUG); /***/ }), -/***/ 9327: +/***/ 2899: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = { - parallel : __nccwpck_require__(1266), - serial : __nccwpck_require__(3979), - serialOrdered : __nccwpck_require__(2054) + parallel : __nccwpck_require__(1599), + serial : __nccwpck_require__(1713), + serialOrdered : __nccwpck_require__(2168) }; /***/ }), -/***/ 697: +/***/ 734: /***/ ((module) => { // API @@ -8696,10 +9844,10 @@ function clean(key) /***/ }), -/***/ 8132: +/***/ 2712: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var defer = __nccwpck_require__(4960); +var defer = __nccwpck_require__(9407); // API module.exports = async; @@ -8737,7 +9885,7 @@ function async(callback) /***/ }), -/***/ 4960: +/***/ 9407: /***/ ((module) => { module.exports = defer; @@ -8770,11 +9918,11 @@ function defer(fn) /***/ }), -/***/ 3937: +/***/ 5411: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var async = __nccwpck_require__(8132) - , abort = __nccwpck_require__(697) +var async = __nccwpck_require__(2712) + , abort = __nccwpck_require__(734) ; // API @@ -8852,7 +10000,7 @@ function runJob(iterator, key, item, callback) /***/ }), -/***/ 1057: +/***/ 8321: /***/ ((module) => { // API @@ -8896,11 +10044,11 @@ function state(list, sortMethod) /***/ }), -/***/ 8127: +/***/ 3114: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var abort = __nccwpck_require__(697) - , async = __nccwpck_require__(8132) +var abort = __nccwpck_require__(734) + , async = __nccwpck_require__(2712) ; // API @@ -8932,12 +10080,12 @@ function terminator(callback) /***/ }), -/***/ 1266: +/***/ 1599: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(3937) - , initState = __nccwpck_require__(1057) - , terminator = __nccwpck_require__(8127) +var iterate = __nccwpck_require__(5411) + , initState = __nccwpck_require__(8321) + , terminator = __nccwpck_require__(3114) ; // Public API @@ -8982,10 +10130,10 @@ function parallel(list, iterator, callback) /***/ }), -/***/ 3979: +/***/ 1713: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var serialOrdered = __nccwpck_require__(2054); +var serialOrdered = __nccwpck_require__(2168); // Public API module.exports = serial; @@ -9006,12 +10154,12 @@ function serial(list, iterator, callback) /***/ }), -/***/ 2054: +/***/ 2168: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var iterate = __nccwpck_require__(3937) - , initState = __nccwpck_require__(1057) - , terminator = __nccwpck_require__(8127) +var iterate = __nccwpck_require__(5411) + , initState = __nccwpck_require__(8321) + , terminator = __nccwpck_require__(3114) ; // Public API @@ -9088,7 +10236,7 @@ function descending(a, b) /***/ }), -/***/ 3464: +/***/ 9833: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { @@ -9307,14 +10455,14 @@ module.exports.canonicalizeResource = canonicalizeResource /***/ }), -/***/ 2817: +/***/ 4164: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { var aws4 = exports, url = __nccwpck_require__(7310), querystring = __nccwpck_require__(3477), crypto = __nccwpck_require__(6113), - lru = __nccwpck_require__(6776), + lru = __nccwpck_require__(1540), credentialsCache = lru(1000) // http://docs.amazonwebservices.com/general/latest/gr/signature-version-4.html @@ -9687,7 +10835,7 @@ aws4.sign = function(request, credentials) { /***/ }), -/***/ 6776: +/***/ 1540: /***/ ((module) => { module.exports = function(size) { @@ -9790,13 +10938,13 @@ function DoublyLinkedNode(key, val) { /***/ }), -/***/ 5634: +/***/ 4972: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var crypto_hash_sha512 = (__nccwpck_require__(8180).lowlevel.crypto_hash); +var crypto_hash_sha512 = (__nccwpck_require__(3465).lowlevel.crypto_hash); /* * This file is a 1:1 port from the OpenBSD blowfish.c and bcrypt_pbkdf.c. As a @@ -10354,7 +11502,7 @@ module.exports = { /***/ }), -/***/ 3468: +/***/ 2777: /***/ ((module) => { "use strict"; @@ -10383,16 +11531,16 @@ Promise.prototype.any = function () { /***/ }), -/***/ 4633: +/***/ 1170: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; var firstLineError; try {throw new Error(); } catch (e) {firstLineError = e;} -var schedule = __nccwpck_require__(4510); -var Queue = __nccwpck_require__(6135); -var util = __nccwpck_require__(341); +var schedule = __nccwpck_require__(3117); +var Queue = __nccwpck_require__(7340); +var util = __nccwpck_require__(7640); function Async() { this._isTickUsed = false; @@ -10541,7 +11689,7 @@ module.exports.firstLineError = firstLineError; /***/ }), -/***/ 8630: +/***/ 8116: /***/ ((module) => { "use strict"; @@ -10621,7 +11769,7 @@ Promise.bind = function (thisArg, value) { /***/ }), -/***/ 1857: +/***/ 2195: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -10633,14 +11781,14 @@ function noConflict() { catch (e) {} return bluebird; } -var bluebird = __nccwpck_require__(8936)(); +var bluebird = __nccwpck_require__(9525)(); bluebird.noConflict = noConflict; module.exports = bluebird; /***/ }), -/***/ 9410: +/***/ 8463: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -10653,7 +11801,7 @@ if (cr) { } module.exports = function(Promise) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var canEvaluate = util.canEvaluate; var isIdentifier = util.isIdentifier; @@ -10771,14 +11919,14 @@ Promise.prototype.get = function (propertyName) { /***/ }), -/***/ 1700: +/***/ 2466: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise) { -var errors = __nccwpck_require__(9464); -var async = __nccwpck_require__(4633); +var errors = __nccwpck_require__(1614); +var async = __nccwpck_require__(1170); var CancellationError = errors.CancellationError; Promise.prototype._cancel = function (reason) { @@ -10827,14 +11975,14 @@ Promise.prototype.fork = function (didFulfill, didReject, didProgress) { /***/ }), -/***/ 9185: +/***/ 6197: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function() { -var async = __nccwpck_require__(4633); -var util = __nccwpck_require__(341); +var async = __nccwpck_require__(1170); +var util = __nccwpck_require__(7640); var bluebirdFramePattern = /[\\\/]bluebird[\\\/]js[\\\/](main|debug|zalgo|instrumented)/; var stackFramePattern = null; @@ -11328,17 +12476,17 @@ return CapturedTrace; /***/ }), -/***/ 2622: +/***/ 6030: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(NEXT_FILTER) { -var util = __nccwpck_require__(341); -var errors = __nccwpck_require__(9464); +var util = __nccwpck_require__(7640); +var errors = __nccwpck_require__(1614); var tryCatch = util.tryCatch; var errorObj = util.errorObj; -var keys = (__nccwpck_require__(7182).keys); +var keys = (__nccwpck_require__(7862).keys); var TypeError = errors.TypeError; function CatchFilter(instances, callback, promise) { @@ -11402,7 +12550,7 @@ return CatchFilter; /***/ }), -/***/ 1483: +/***/ 3197: /***/ ((module) => { "use strict"; @@ -11448,16 +12596,16 @@ return createContext; /***/ }), -/***/ 1696: +/***/ 5328: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, CapturedTrace) { var getDomain = Promise._getDomain; -var async = __nccwpck_require__(4633); -var Warning = (__nccwpck_require__(9464).Warning); -var util = __nccwpck_require__(341); +var async = __nccwpck_require__(1170); +var Warning = (__nccwpck_require__(1614).Warning); +var util = __nccwpck_require__(7640); var canAttachTrace = util.canAttachTrace; var unhandledRejectionHandled; var possiblyUnhandledRejection; @@ -11618,12 +12766,12 @@ return function() { /***/ }), -/***/ 374: +/***/ 8595: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var isPrimitive = util.isPrimitive; module.exports = function(Promise) { @@ -11689,7 +12837,7 @@ Promise.prototype.thenThrow = function (reason) { /***/ }), -/***/ 8533: +/***/ 4823: /***/ ((module) => { "use strict"; @@ -11709,14 +12857,14 @@ Promise.each = function (promises, fn) { /***/ }), -/***/ 9464: +/***/ 1614: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var es5 = __nccwpck_require__(7182); +var es5 = __nccwpck_require__(7862); var Objectfreeze = es5.freeze; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var inherits = util.inherits; var notEnumerableProp = util.notEnumerableProp; @@ -11828,7 +12976,7 @@ module.exports = { /***/ }), -/***/ 7182: +/***/ 7862: /***/ ((module) => { var isES5 = (function(){ @@ -11915,7 +13063,7 @@ if (isES5) { /***/ }), -/***/ 7051: +/***/ 4553: /***/ ((module) => { "use strict"; @@ -11935,13 +13083,13 @@ Promise.filter = function (promises, fn, options) { /***/ }), -/***/ 3757: +/***/ 1565: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, NEXT_FILTER, tryConvertToPromise) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var isPrimitive = util.isPrimitive; var thrower = util.thrower; @@ -12041,7 +13189,7 @@ Promise.prototype.tap = function (handler) { /***/ }), -/***/ 316: +/***/ 2093: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -12050,9 +13198,9 @@ module.exports = function(Promise, apiRejection, INTERNAL, tryConvertToPromise) { -var errors = __nccwpck_require__(9464); +var errors = __nccwpck_require__(1614); var TypeError = errors.TypeError; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var errorObj = util.errorObj; var tryCatch = util.tryCatch; var yieldHandlers = []; @@ -12185,14 +13333,14 @@ Promise.spawn = function (generatorFunction) { /***/ }), -/***/ 997: +/***/ 387: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var canEvaluate = util.canEvaluate; var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -12300,7 +13448,7 @@ Promise.join = function () { /***/ }), -/***/ 7470: +/***/ 3327: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -12311,8 +13459,8 @@ module.exports = function(Promise, tryConvertToPromise, INTERNAL) { var getDomain = Promise._getDomain; -var async = __nccwpck_require__(4633); -var util = __nccwpck_require__(341); +var async = __nccwpck_require__(1170); +var util = __nccwpck_require__(7640); var tryCatch = util.tryCatch; var errorObj = util.errorObj; var PENDING = {}; @@ -12441,14 +13589,14 @@ Promise.map = function (promises, fn, options, _filter) { /***/ }), -/***/ 8305: +/***/ 9626: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL, tryConvertToPromise, apiRejection) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var tryCatch = util.tryCatch; Promise.method = function (fn) { @@ -12493,14 +13641,14 @@ Promise.prototype._resolveFromSyncValue = function (value) { /***/ }), -/***/ 8839: +/***/ 3999: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise) { -var util = __nccwpck_require__(341); -var async = __nccwpck_require__(4633); +var util = __nccwpck_require__(7640); +var async = __nccwpck_require__(1170); var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -12560,14 +13708,14 @@ Promise.prototype.nodeify = function (nodeback, options) { /***/ }), -/***/ 7941: +/***/ 553: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, PromiseArray) { -var util = __nccwpck_require__(341); -var async = __nccwpck_require__(4633); +var util = __nccwpck_require__(7640); +var async = __nccwpck_require__(1170); var tryCatch = util.tryCatch; var errorObj = util.errorObj; @@ -12644,7 +13792,7 @@ Promise.prototype._progressUnchecked = function (progressValue) { /***/ }), -/***/ 8936: +/***/ 9525: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -12660,7 +13808,7 @@ var apiRejection = function(msg) { return Promise.reject(new TypeError(msg)); }; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var getDomain; if (util.isNode) { @@ -12677,8 +13825,8 @@ if (util.isNode) { util.notEnumerableProp(Promise, "_getDomain", getDomain); var UNDEFINED_BINDING = {}; -var async = __nccwpck_require__(4633); -var errors = __nccwpck_require__(9464); +var async = __nccwpck_require__(1170); +var errors = __nccwpck_require__(1614); var TypeError = Promise.TypeError = errors.TypeError; Promise.RangeError = errors.RangeError; Promise.CancellationError = errors.CancellationError; @@ -12689,17 +13837,17 @@ Promise.AggregateError = errors.AggregateError; var INTERNAL = function(){}; var APPLY = {}; var NEXT_FILTER = {e: null}; -var tryConvertToPromise = __nccwpck_require__(545)(Promise, INTERNAL); +var tryConvertToPromise = __nccwpck_require__(487)(Promise, INTERNAL); var PromiseArray = - __nccwpck_require__(1869)(Promise, INTERNAL, + __nccwpck_require__(9814)(Promise, INTERNAL, tryConvertToPromise, apiRejection); -var CapturedTrace = __nccwpck_require__(9185)(); -var isDebugging = __nccwpck_require__(1696)(Promise, CapturedTrace); +var CapturedTrace = __nccwpck_require__(6197)(); +var isDebugging = __nccwpck_require__(5328)(Promise, CapturedTrace); /*jshint unused:false*/ var createContext = - __nccwpck_require__(1483)(Promise, CapturedTrace, isDebugging); -var CatchFilter = __nccwpck_require__(2622)(NEXT_FILTER); -var PromiseResolver = __nccwpck_require__(4889); + __nccwpck_require__(3197)(Promise, CapturedTrace, isDebugging); +var CatchFilter = __nccwpck_require__(6030)(NEXT_FILTER); +var PromiseResolver = __nccwpck_require__(7300); var nodebackForPromise = PromiseResolver._nodebackForPromise; var errorObj = util.errorObj; var tryCatch = util.tryCatch; @@ -13356,31 +14504,31 @@ util.notEnumerableProp(Promise, "_makeSelfResolutionError", makeSelfResolutionError); -__nccwpck_require__(7941)(Promise, PromiseArray); -__nccwpck_require__(8305)(Promise, INTERNAL, tryConvertToPromise, apiRejection); -__nccwpck_require__(8630)(Promise, INTERNAL, tryConvertToPromise); -__nccwpck_require__(3757)(Promise, NEXT_FILTER, tryConvertToPromise); -__nccwpck_require__(374)(Promise); -__nccwpck_require__(2122)(Promise); -__nccwpck_require__(997)(Promise, PromiseArray, tryConvertToPromise, INTERNAL); +__nccwpck_require__(553)(Promise, PromiseArray); +__nccwpck_require__(9626)(Promise, INTERNAL, tryConvertToPromise, apiRejection); +__nccwpck_require__(8116)(Promise, INTERNAL, tryConvertToPromise); +__nccwpck_require__(1565)(Promise, NEXT_FILTER, tryConvertToPromise); +__nccwpck_require__(8595)(Promise); +__nccwpck_require__(7202)(Promise); +__nccwpck_require__(387)(Promise, PromiseArray, tryConvertToPromise, INTERNAL); Promise.version = "2.11.0"; Promise.Promise = Promise; -__nccwpck_require__(7470)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); -__nccwpck_require__(1700)(Promise); -__nccwpck_require__(9139)(Promise, apiRejection, tryConvertToPromise, createContext); -__nccwpck_require__(316)(Promise, apiRejection, INTERNAL, tryConvertToPromise); -__nccwpck_require__(8839)(Promise); -__nccwpck_require__(9410)(Promise); -__nccwpck_require__(7289)(Promise, PromiseArray, tryConvertToPromise, apiRejection); -__nccwpck_require__(4965)(Promise, INTERNAL, tryConvertToPromise, apiRejection); -__nccwpck_require__(5644)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); -__nccwpck_require__(8199)(Promise, PromiseArray); -__nccwpck_require__(825)(Promise, PromiseArray, apiRejection); -__nccwpck_require__(1721)(Promise, INTERNAL); -__nccwpck_require__(3468)(Promise); -__nccwpck_require__(8533)(Promise, INTERNAL); -__nccwpck_require__(2876)(Promise, INTERNAL); -__nccwpck_require__(7051)(Promise, INTERNAL); +__nccwpck_require__(3327)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); +__nccwpck_require__(2466)(Promise); +__nccwpck_require__(6060)(Promise, apiRejection, tryConvertToPromise, createContext); +__nccwpck_require__(2093)(Promise, apiRejection, INTERNAL, tryConvertToPromise); +__nccwpck_require__(3999)(Promise); +__nccwpck_require__(8463)(Promise); +__nccwpck_require__(1478)(Promise, PromiseArray, tryConvertToPromise, apiRejection); +__nccwpck_require__(9025)(Promise, INTERNAL, tryConvertToPromise, apiRejection); +__nccwpck_require__(4025)(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); +__nccwpck_require__(5997)(Promise, PromiseArray); +__nccwpck_require__(6496)(Promise, PromiseArray, apiRejection); +__nccwpck_require__(2360)(Promise, INTERNAL); +__nccwpck_require__(2777)(Promise); +__nccwpck_require__(4823)(Promise, INTERNAL); +__nccwpck_require__(970)(Promise, INTERNAL); +__nccwpck_require__(4553)(Promise, INTERNAL); util.toFastProperties(Promise); util.toFastProperties(Promise.prototype); @@ -13411,14 +14559,14 @@ __nccwpck_require__(7051)(Promise, INTERNAL); /***/ }), -/***/ 1869: +/***/ 9814: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL, tryConvertToPromise, apiRejection) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var isArray = util.isArray; function toResolutionValue(val) { @@ -13561,18 +14709,18 @@ return PromiseArray; /***/ }), -/***/ 4889: +/***/ 7300: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var maybeWrapAsError = util.maybeWrapAsError; -var errors = __nccwpck_require__(9464); +var errors = __nccwpck_require__(1614); var TimeoutError = errors.TimeoutError; var OperationalError = errors.OperationalError; var haveGetters = util.haveGetters; -var es5 = __nccwpck_require__(7182); +var es5 = __nccwpck_require__(7862); function isUntypedError(obj) { return obj instanceof Error && @@ -13692,19 +14840,19 @@ module.exports = PromiseResolver; /***/ }), -/***/ 1721: +/***/ 2360: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL) { var THIS = {}; -var util = __nccwpck_require__(341); -var nodebackForPromise = (__nccwpck_require__(4889)._nodebackForPromise); +var util = __nccwpck_require__(7640); +var nodebackForPromise = (__nccwpck_require__(7300)._nodebackForPromise); var withAppended = util.withAppended; var maybeWrapAsError = util.maybeWrapAsError; var canEvaluate = util.canEvaluate; -var TypeError = (__nccwpck_require__(9464).TypeError); +var TypeError = (__nccwpck_require__(1614).TypeError); var defaultSuffix = "Async"; var defaultPromisified = {__isPromisified__: true}; var noCopyProps = [ @@ -14006,16 +15154,16 @@ Promise.promisifyAll = function (target, options) { /***/ }), -/***/ 7289: +/***/ 1478: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function( Promise, PromiseArray, tryConvertToPromise, apiRejection) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var isObject = util.isObject; -var es5 = __nccwpck_require__(7182); +var es5 = __nccwpck_require__(7862); function PropertiesPromiseArray(obj) { var keys = es5.keys(obj); @@ -14093,7 +15241,7 @@ Promise.props = function (promises) { /***/ }), -/***/ 6135: +/***/ 7340: /***/ ((module) => { "use strict"; @@ -14191,14 +15339,14 @@ module.exports = Queue; /***/ }), -/***/ 4965: +/***/ 9025: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function( Promise, INTERNAL, tryConvertToPromise, apiRejection) { -var isArray = (__nccwpck_require__(341).isArray); +var isArray = (__nccwpck_require__(7640).isArray); var raceLater = function (promise) { return promise.then(function(array) { @@ -14246,7 +15394,7 @@ Promise.prototype.race = function () { /***/ }), -/***/ 5644: +/***/ 4025: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -14257,8 +15405,8 @@ module.exports = function(Promise, tryConvertToPromise, INTERNAL) { var getDomain = Promise._getDomain; -var async = __nccwpck_require__(4633); -var util = __nccwpck_require__(341); +var async = __nccwpck_require__(1170); +var util = __nccwpck_require__(7640); var tryCatch = util.tryCatch; var errorObj = util.errorObj; function ReductionPromiseArray(promises, fn, accum, _each) { @@ -14402,13 +15550,13 @@ Promise.reduce = function (promises, fn, initialValue, _each) { /***/ }), -/***/ 4510: +/***/ 3117: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; var schedule; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var noAsyncScheduler = function() { throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a"); }; @@ -14445,7 +15593,7 @@ module.exports = schedule; /***/ }), -/***/ 8199: +/***/ 5997: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -14453,7 +15601,7 @@ module.exports = schedule; module.exports = function(Promise, PromiseArray) { var PromiseInspection = Promise.PromiseInspection; -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); function SettledPromiseArray(values) { this.constructor$(values); @@ -14493,16 +15641,16 @@ Promise.prototype.settle = function () { /***/ }), -/***/ 825: +/***/ 6496: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, PromiseArray, apiRejection) { -var util = __nccwpck_require__(341); -var RangeError = (__nccwpck_require__(9464).RangeError); -var AggregateError = (__nccwpck_require__(9464).AggregateError); +var util = __nccwpck_require__(7640); +var RangeError = (__nccwpck_require__(1614).RangeError); +var AggregateError = (__nccwpck_require__(1614).AggregateError); var isArray = util.isArray; @@ -14626,7 +15774,7 @@ Promise._SomePromiseArray = SomePromiseArray; /***/ }), -/***/ 2122: +/***/ 7202: /***/ ((module) => { "use strict"; @@ -14728,13 +15876,13 @@ Promise.PromiseInspection = PromiseInspection; /***/ }), -/***/ 545: +/***/ 487: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var errorObj = util.errorObj; var isObject = util.isObject; @@ -14820,13 +15968,13 @@ return tryConvertToPromise; /***/ }), -/***/ 2876: +/***/ 970: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function(Promise, INTERNAL) { -var util = __nccwpck_require__(341); +var util = __nccwpck_require__(7640); var TimeoutError = Promise.TimeoutError; var afterTimeout = function (promise, message) { @@ -14892,15 +16040,15 @@ Promise.prototype.timeout = function (ms, message) { /***/ }), -/***/ 9139: +/***/ 6060: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; module.exports = function (Promise, apiRejection, tryConvertToPromise, createContext) { - var TypeError = (__nccwpck_require__(9464).TypeError); - var inherits = (__nccwpck_require__(341).inherits); + var TypeError = (__nccwpck_require__(1614).TypeError); + var inherits = (__nccwpck_require__(7640).inherits); var PromiseInspection = Promise.PromiseInspection; function inspectionMapper(inspections) { @@ -15113,12 +16261,12 @@ module.exports = function (Promise, apiRejection, tryConvertToPromise, /***/ }), -/***/ 341: +/***/ 7640: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var es5 = __nccwpck_require__(7182); +var es5 = __nccwpck_require__(7862); var canEvaluate = typeof navigator == "undefined"; var haveGetters = (function(){ try { @@ -15442,7 +16590,7 @@ module.exports = ret; /***/ }), -/***/ 1122: +/***/ 6046: /***/ ((module) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -15573,7 +16721,7 @@ module.exports = BrotliBitReader; /***/ }), -/***/ 8882: +/***/ 7535: /***/ ((__unused_webpack_module, exports) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -15830,7 +16978,7 @@ exports.lookupOffsets = new Uint16Array([ /***/ }), -/***/ 4535: +/***/ 8683: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { var __webpack_unused_export__; @@ -15849,15 +16997,15 @@ var __webpack_unused_export__; limitations under the License. */ -var BrotliInput = (__nccwpck_require__(8524)/* .BrotliInput */ .g); -var BrotliOutput = (__nccwpck_require__(8524)/* .BrotliOutput */ .j); -var BrotliBitReader = __nccwpck_require__(1122); -var BrotliDictionary = __nccwpck_require__(9772); -var HuffmanCode = (__nccwpck_require__(1816)/* .HuffmanCode */ .h); -var BrotliBuildHuffmanTable = (__nccwpck_require__(1816)/* .BrotliBuildHuffmanTable */ .g); -var Context = __nccwpck_require__(8882); -var Prefix = __nccwpck_require__(2955); -var Transform = __nccwpck_require__(3816); +var BrotliInput = (__nccwpck_require__(4607)/* .BrotliInput */ .g); +var BrotliOutput = (__nccwpck_require__(4607)/* .BrotliOutput */ .j); +var BrotliBitReader = __nccwpck_require__(6046); +var BrotliDictionary = __nccwpck_require__(6644); +var HuffmanCode = (__nccwpck_require__(2553)/* .HuffmanCode */ .h); +var BrotliBuildHuffmanTable = (__nccwpck_require__(2553)/* .BrotliBuildHuffmanTable */ .g); +var Context = __nccwpck_require__(7535); +var Prefix = __nccwpck_require__(8598); +var Transform = __nccwpck_require__(1766); var kDefaultCodeLength = 8; var kCodeLengthRepeatCode = 16; @@ -16776,7 +17924,7 @@ BrotliDictionary.init(); /***/ }), -/***/ 5256: +/***/ 6635: /***/ ((__unused_webpack_module, exports) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -26252,7 +27400,7 @@ exports.init = function() { /***/ }), -/***/ 9772: +/***/ 6644: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -26272,7 +27420,7 @@ exports.init = function() { Collection of static dictionary words. */ -var data = __nccwpck_require__(5256); +var data = __nccwpck_require__(6635); exports.init = function() { exports.dictionary = data.init(); }; @@ -26295,7 +27443,7 @@ exports.maxDictionaryWordLength = 24; /***/ }), -/***/ 1816: +/***/ 2553: /***/ ((__unused_webpack_module, exports) => { function HuffmanCode(bits, value) { @@ -26425,7 +27573,7 @@ exports.g = function(root_table, table, root_bits, code_lengths, code_lengths_si /***/ }), -/***/ 2955: +/***/ 8598: /***/ ((__unused_webpack_module, exports) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -26492,7 +27640,7 @@ exports.kCopyRangeLut = [ /***/ }), -/***/ 8524: +/***/ 4607: /***/ ((__unused_webpack_module, exports) => { function BrotliInput(buffer) { @@ -26533,7 +27681,7 @@ exports.j = BrotliOutput; /***/ }), -/***/ 3816: +/***/ 1766: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { /* Copyright 2013 Google Inc. All Rights Reserved. @@ -26553,7 +27701,7 @@ exports.j = BrotliOutput; Transformations on dictionary words. */ -var BrotliDictionary = __nccwpck_require__(9772); +var BrotliDictionary = __nccwpck_require__(6644); var kIdentity = 0; var kOmitLast1 = 1; @@ -26787,15 +27935,15 @@ exports.transformDictionaryWord = function(dst, idx, word, len, transform) { /***/ }), -/***/ 2199: +/***/ 1495: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(4535).BrotliDecompressBuffer; +module.exports = __nccwpck_require__(8683).BrotliDecompressBuffer; /***/ }), -/***/ 8955: +/***/ 6133: /***/ ((module) => { function Caseless (dict) { @@ -26869,12 +28017,12 @@ module.exports.httpify = function (resp, headers) { /***/ }), -/***/ 2336: +/***/ 4592: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var util = __nccwpck_require__(3837); var Stream = (__nccwpck_require__(2781).Stream); -var DelayedStream = __nccwpck_require__(9449); +var DelayedStream = __nccwpck_require__(3087); module.exports = CombinedStream; function CombinedStream() { @@ -27084,7 +28232,7 @@ CombinedStream.prototype._emitError = function(err) { /***/ }), -/***/ 9194: +/***/ 4494: /***/ ((__unused_webpack_module, exports) => { var __webpack_unused_export__; @@ -27199,7 +28347,7 @@ function objectToString(o) { /***/ }), -/***/ 9449: +/***/ 3087: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Stream = (__nccwpck_require__(2781).Stream); @@ -27313,14 +28461,14 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() { /***/ }), -/***/ 7886: +/***/ 9838: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { var crypto = __nccwpck_require__(6113); -var BigInteger = (__nccwpck_require__(9778).BigInteger); -var ECPointFp = (__nccwpck_require__(5561).ECPointFp); -var Buffer = (__nccwpck_require__(5827).Buffer); -exports.ECCurves = __nccwpck_require__(2380); +var BigInteger = (__nccwpck_require__(484).BigInteger); +var ECPointFp = (__nccwpck_require__(1220).ECPointFp); +var Buffer = (__nccwpck_require__(4217).Buffer); +exports.ECCurves = __nccwpck_require__(3157); // zero prepad function unstupid(hex,len) @@ -27378,7 +28526,7 @@ exports.ECKey = function(curve, key, isPublic) /***/ }), -/***/ 5561: +/***/ 1220: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Basic Javascript Elliptic Curve implementation @@ -27386,7 +28534,7 @@ exports.ECKey = function(curve, key, isPublic) // Only Fp curves implemented for now // Requires jsbn.js and jsbn2.js -var BigInteger = (__nccwpck_require__(9778).BigInteger) +var BigInteger = (__nccwpck_require__(484).BigInteger) var Barrett = BigInteger.prototype.Barrett // ---------------- @@ -27946,14 +29094,14 @@ module.exports = exports /***/ }), -/***/ 2380: +/***/ 3157: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Named EC curves // Requires ec.js, jsbn.js, and jsbn2.js -var BigInteger = (__nccwpck_require__(9778).BigInteger) -var ECCurveFp = (__nccwpck_require__(5561).ECCurveFp) +var BigInteger = (__nccwpck_require__(484).BigInteger) +var ECCurveFp = (__nccwpck_require__(1220).ECCurveFp) // ---------------- @@ -28123,7 +29271,7 @@ module.exports = { /***/ }), -/***/ 6468: +/***/ 9876: /***/ ((module) => { "use strict"; @@ -28248,7 +29396,7 @@ module.exports = function extend() { /***/ }), -/***/ 5350: +/***/ 6684: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { /* @@ -28438,7 +29586,7 @@ function dumpException(ex) /***/ }), -/***/ 7120: +/***/ 5066: /***/ ((module) => { "use strict"; @@ -28492,7 +29640,7 @@ module.exports = function equal(a, b) { /***/ }), -/***/ 2181: +/***/ 428: /***/ ((module) => { "use strict"; @@ -28559,7 +29707,7 @@ module.exports = function (data, opts) { /***/ }), -/***/ 5760: +/***/ 5319: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { module.exports = ForeverAgent @@ -28704,7 +29852,7 @@ function createConnectionSSL (port, host, options) { /***/ }), -/***/ 4657: +/***/ 3900: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -28734,7 +29882,7 @@ module.exports = { /***/ }), -/***/ 9961: +/***/ 2017: /***/ ((module) => { function HARError (errors) { @@ -28758,12 +29906,12 @@ module.exports = HARError /***/ }), -/***/ 241: +/***/ 6562: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var Ajv = __nccwpck_require__(2235) -var HARError = __nccwpck_require__(9961) -var schemas = __nccwpck_require__(4657) +var Ajv = __nccwpck_require__(3718) +var HARError = __nccwpck_require__(2017) +var schemas = __nccwpck_require__(3900) var ajv @@ -28867,15 +30015,15 @@ exports.timings = function (data) { /***/ }), -/***/ 9835: +/***/ 7958: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. -var parser = __nccwpck_require__(4362); -var signer = __nccwpck_require__(1304); -var verify = __nccwpck_require__(5231); -var utils = __nccwpck_require__(3240); +var parser = __nccwpck_require__(2707); +var signer = __nccwpck_require__(9215); +var verify = __nccwpck_require__(1873); +var utils = __nccwpck_require__(2762); @@ -28903,14 +30051,14 @@ module.exports = { /***/ }), -/***/ 4362: +/***/ 2707: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2012 Joyent, Inc. All rights reserved. -var assert = __nccwpck_require__(6381); +var assert = __nccwpck_require__(4500); var util = __nccwpck_require__(3837); -var utils = __nccwpck_require__(3240); +var utils = __nccwpck_require__(2762); @@ -29287,17 +30435,17 @@ module.exports = { /***/ }), -/***/ 1304: +/***/ 9215: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2012 Joyent, Inc. All rights reserved. -var assert = __nccwpck_require__(6381); +var assert = __nccwpck_require__(4500); var crypto = __nccwpck_require__(6113); var util = __nccwpck_require__(3837); -var sshpk = __nccwpck_require__(7844); -var jsprim = __nccwpck_require__(9407); -var utils = __nccwpck_require__(3240); +var sshpk = __nccwpck_require__(8720); +var jsprim = __nccwpck_require__(9118); +var utils = __nccwpck_require__(2762); var sprintf = (__nccwpck_require__(3837).format); @@ -29777,13 +30925,13 @@ module.exports = { /***/ }), -/***/ 3240: +/***/ 2762: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2012 Joyent, Inc. All rights reserved. -var assert = __nccwpck_require__(6381); -var sshpk = __nccwpck_require__(7844); +var assert = __nccwpck_require__(4500); +var sshpk = __nccwpck_require__(8720); var util = __nccwpck_require__(3837); var HASH_ALGOS = { @@ -29902,15 +31050,15 @@ module.exports = { /***/ }), -/***/ 5231: +/***/ 1873: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. -var assert = __nccwpck_require__(6381); +var assert = __nccwpck_require__(4500); var crypto = __nccwpck_require__(6113); -var sshpk = __nccwpck_require__(7844); -var utils = __nccwpck_require__(3240); +var sshpk = __nccwpck_require__(8720); +var utils = __nccwpck_require__(2762); var HASH_ALGOS = utils.HASH_ALGOS; var PK_ALGOS = utils.PK_ALGOS; @@ -29997,7 +31145,7 @@ module.exports = { /***/ }), -/***/ 5668: +/***/ 2991: /***/ ((module) => { module.exports = isTypedArray @@ -30045,7 +31193,7 @@ function isLooseTypedArray(arr) { /***/ }), -/***/ 5458: +/***/ 7722: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var stream = __nccwpck_require__(2781) @@ -30079,20 +31227,20 @@ module.exports.isDuplex = isDuplex /***/ }), -/***/ 7871: +/***/ 3949: /***/ ((module, exports, __nccwpck_require__) => { "use strict"; -var _interopRequireDefault = __nccwpck_require__(27); +var _interopRequireDefault = __nccwpck_require__(1103); Object.defineProperty(exports, "__esModule", ({ value: true })); exports["default"] = void 0; -var _postmanRequest = _interopRequireDefault(__nccwpck_require__(3275)); +var _postmanRequest = _interopRequireDefault(__nccwpck_require__(2307)); var _url = _interopRequireDefault(__nccwpck_require__(7310)); @@ -32412,7 +33560,7 @@ module.exports = exports.default; /***/ }), -/***/ 9778: +/***/ 484: /***/ (function(module, exports) { (function(){ @@ -33773,7 +34921,7 @@ module.exports = exports.default; /***/ }), -/***/ 6899: +/***/ 7155: /***/ ((module) => { "use strict"; @@ -33870,7 +35018,7 @@ function escapeJsonPtr(str) { /***/ }), -/***/ 8465: +/***/ 5824: /***/ (function(module) { /** @@ -34148,7 +35296,7 @@ return exports; /***/ }), -/***/ 968: +/***/ 9184: /***/ ((module, exports) => { exports = module.exports = stringify @@ -34182,19 +35330,19 @@ function serializer(replacer, cycleReplacer) { /***/ }), -/***/ 9407: +/***/ 9118: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { /* * lib/jsprim.js: utilities for primitive JavaScript types */ -var mod_assert = __nccwpck_require__(6381); +var mod_assert = __nccwpck_require__(4500); var mod_util = __nccwpck_require__(3837); -var mod_extsprintf = __nccwpck_require__(5350); -var mod_verror = __nccwpck_require__(4862); -var mod_jsonschema = __nccwpck_require__(8465); +var mod_extsprintf = __nccwpck_require__(6684); +var mod_verror = __nccwpck_require__(1152); +var mod_jsonschema = __nccwpck_require__(5824); /* * Public interface @@ -34924,7 +36072,7 @@ function mergeObjects(provided, overrides, defaults) /***/ }), -/***/ 9260: +/***/ 5348: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /*! @@ -34943,7 +36091,7 @@ module.exports = __nccwpck_require__(3765) /***/ }), -/***/ 2720: +/***/ 3491: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -34961,7 +36109,7 @@ module.exports = __nccwpck_require__(3765) * @private */ -var db = __nccwpck_require__(9260) +var db = __nccwpck_require__(5348) var extname = (__nccwpck_require__(1017).extname) /** @@ -35139,7 +36287,7 @@ function populateMaps (extensions, types) { /***/ }), -/***/ 5530: +/***/ 8574: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { var crypto = __nccwpck_require__(6113) @@ -35291,7 +36439,7 @@ exports.generateBase = generateBase /***/ }), -/***/ 3878: +/***/ 6860: /***/ (function(module) { // Generated by CoffeeScript 1.12.2 @@ -35334,7 +36482,7 @@ exports.generateBase = generateBase /***/ }), -/***/ 3275: +/***/ 2307: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -35355,8 +36503,8 @@ exports.generateBase = generateBase var tls = __nccwpck_require__(4404) -var extend = __nccwpck_require__(6468) -var cookies = __nccwpck_require__(219) +var extend = __nccwpck_require__(9876) +var cookies = __nccwpck_require__(3857) // organize params for patch, post, put, head, del function initParams (uri, options, callback) { @@ -35560,7 +36708,7 @@ request.disableNodeExtraCACerts = function () { // Exports module.exports = request -request.Request = __nccwpck_require__(3537) +request.Request = __nccwpck_require__(3094) request.initParams = initParams // Backwards compatibility for request.debug @@ -35577,15 +36725,15 @@ Object.defineProperty(request, 'debug', { /***/ }), -/***/ 3619: +/***/ 6555: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var caseless = __nccwpck_require__(8955) -var uuid = __nccwpck_require__(5180) -var helpers = __nccwpck_require__(397) +var caseless = __nccwpck_require__(6133) +var uuid = __nccwpck_require__(9470) +var helpers = __nccwpck_require__(774) var md5 = helpers.md5 var toBase64 = helpers.toBase64 @@ -35752,20 +36900,20 @@ exports.g = Auth /***/ }), -/***/ 7200: +/***/ 3522: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var Buffer = (__nccwpck_require__(3925).Buffer) +var Buffer = (__nccwpck_require__(9011).Buffer) var Transform = (__nccwpck_require__(2781).Transform) var zlib = __nccwpck_require__(9796) var inherits = (__nccwpck_require__(3837).inherits) var createBrotliDecompress = zlib.createBrotliDecompress if (typeof createBrotliDecompress !== 'function') { - var brotliDecompressBuffer = __nccwpck_require__(2199) + var brotliDecompressBuffer = __nccwpck_require__(1495) var BrotliDecompress = function BrotliDecompress (options) { this.options = options @@ -35814,13 +36962,13 @@ module.exports.createBrotliDecompress = createBrotliDecompress /***/ }), -/***/ 219: +/***/ 3857: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var tough = __nccwpck_require__(7461) +var tough = __nccwpck_require__(5197) var Cookie = tough.Cookie var CookieJar = tough.CookieJar @@ -35842,7 +36990,7 @@ exports.jar = function (store) { /***/ }), -/***/ 8355: +/***/ 1130: /***/ ((module) => { "use strict"; @@ -35929,7 +37077,7 @@ module.exports = getProxyFromURI /***/ }), -/***/ 6368: +/***/ 5986: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -35937,8 +37085,8 @@ module.exports = getProxyFromURI var fs = __nccwpck_require__(7147) var qs = __nccwpck_require__(3477) -var validate = __nccwpck_require__(241) -var extend = __nccwpck_require__(6468) +var validate = __nccwpck_require__(6562) +var extend = __nccwpck_require__(9876) function Har (request) { this.request = request @@ -36142,7 +37290,7 @@ exports.t = Har /***/ }), -/***/ 5873: +/***/ 2186: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -36239,15 +37387,15 @@ exports.header = function (uri, method, opts) { /***/ }), -/***/ 397: +/***/ 774: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var jsonSafeStringify = __nccwpck_require__(968) +var jsonSafeStringify = __nccwpck_require__(9184) var crypto = __nccwpck_require__(6113) -var Buffer = (__nccwpck_require__(3925).Buffer) +var Buffer = (__nccwpck_require__(9011).Buffer) var defer = typeof setImmediate === 'undefined' ? process.nextTick @@ -36314,7 +37462,7 @@ exports.defer = defer /***/ }), -/***/ 7962: +/***/ 5365: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -36323,7 +37471,7 @@ exports.defer = defer var zlib = __nccwpck_require__(9796) var stream = __nccwpck_require__(2781) var inherit = (__nccwpck_require__(3837).inherits) -var Buffer = (__nccwpck_require__(3925).Buffer) +var Buffer = (__nccwpck_require__(9011).Buffer) var Inflate Inflate = function (options) { @@ -36386,16 +37534,16 @@ module.exports.createInflate = function (options) { /***/ }), -/***/ 509: +/***/ 7261: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var uuid = __nccwpck_require__(5180) -var CombinedStream = __nccwpck_require__(2336) -var isstream = __nccwpck_require__(5458) -var Buffer = (__nccwpck_require__(3925).Buffer) +var uuid = __nccwpck_require__(9470) +var CombinedStream = __nccwpck_require__(4592) +var isstream = __nccwpck_require__(7722) +var Buffer = (__nccwpck_require__(9011).Buffer) function Multipart (request) { this.request = request @@ -36506,18 +37654,18 @@ exports.$ = Multipart /***/ }), -/***/ 7058: +/***/ 7511: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var qs = __nccwpck_require__(7913) -var caseless = __nccwpck_require__(8955) -var uuid = __nccwpck_require__(5180) -var oauth = __nccwpck_require__(5530) +var qs = __nccwpck_require__(8680) +var caseless = __nccwpck_require__(6133) +var uuid = __nccwpck_require__(9470) +var oauth = __nccwpck_require__(8574) var crypto = __nccwpck_require__(6113) -var Buffer = (__nccwpck_require__(3925).Buffer) +var Buffer = (__nccwpck_require__(9011).Buffer) function OAuth (request) { this.request = request @@ -36661,13 +37809,13 @@ exports.f = OAuth /***/ }), -/***/ 6942: +/***/ 1589: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var qs = __nccwpck_require__(7913) +var qs = __nccwpck_require__(8680) var querystring = __nccwpck_require__(3477) function Querystring (request) { @@ -36719,7 +37867,7 @@ exports.h = Querystring /***/ }), -/***/ 3296: +/***/ 5907: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -36945,13 +38093,13 @@ exports.l = Redirect /***/ }), -/***/ 4169: +/***/ 673: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var tunnel = __nccwpck_require__(6291) +var tunnel = __nccwpck_require__(8952) var defaultProxyHeaderWhiteList = [ 'accept', @@ -37128,7 +38276,7 @@ exports.n = Tunnel /***/ }), -/***/ 342: +/***/ 3534: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var url = __nccwpck_require__(7310) @@ -37322,7 +38470,7 @@ module.exports.stringify = stringify /***/ }), -/***/ 3537: +/***/ 3094: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -37335,34 +38483,34 @@ var url = __nccwpck_require__(7310) var util = __nccwpck_require__(3837) var stream = __nccwpck_require__(2781) var zlib = __nccwpck_require__(9796) -var aws2 = __nccwpck_require__(3464) -var aws4 = __nccwpck_require__(2817) -var uuid = __nccwpck_require__(5180) -var httpSignature = __nccwpck_require__(9835) -var mime = __nccwpck_require__(2720) -var caseless = __nccwpck_require__(8955) -var ForeverAgent = __nccwpck_require__(5760) -var FormData = __nccwpck_require__(8401) -var extend = __nccwpck_require__(6468) -var isstream = __nccwpck_require__(5458) -var streamLength = __nccwpck_require__(4321) -var isTypedArray = (__nccwpck_require__(5668).strict) -var helpers = __nccwpck_require__(397) -var cookies = __nccwpck_require__(219) -var getProxyFromURI = __nccwpck_require__(8355) -var Querystring = (__nccwpck_require__(6942)/* .Querystring */ .h) -var Har = (__nccwpck_require__(6368)/* .Har */ .t) -var Auth = (__nccwpck_require__(3619)/* .Auth */ .g) -var OAuth = (__nccwpck_require__(7058)/* .OAuth */ .f) -var hawk = __nccwpck_require__(5873) -var Multipart = (__nccwpck_require__(509)/* .Multipart */ .$) -var Redirect = (__nccwpck_require__(3296)/* .Redirect */ .l) -var Tunnel = (__nccwpck_require__(4169)/* .Tunnel */ .n) -var now = __nccwpck_require__(3878) -var Buffer = (__nccwpck_require__(3925).Buffer) -var inflate = __nccwpck_require__(7962) -var brotli = __nccwpck_require__(7200) -var urlParse = __nccwpck_require__(342) +var aws2 = __nccwpck_require__(9833) +var aws4 = __nccwpck_require__(4164) +var uuid = __nccwpck_require__(9470) +var httpSignature = __nccwpck_require__(7958) +var mime = __nccwpck_require__(3491) +var caseless = __nccwpck_require__(6133) +var ForeverAgent = __nccwpck_require__(5319) +var FormData = __nccwpck_require__(7034) +var extend = __nccwpck_require__(9876) +var isstream = __nccwpck_require__(7722) +var streamLength = __nccwpck_require__(9357) +var isTypedArray = (__nccwpck_require__(2991).strict) +var helpers = __nccwpck_require__(774) +var cookies = __nccwpck_require__(3857) +var getProxyFromURI = __nccwpck_require__(1130) +var Querystring = (__nccwpck_require__(1589)/* .Querystring */ .h) +var Har = (__nccwpck_require__(5986)/* .Har */ .t) +var Auth = (__nccwpck_require__(6555)/* .Auth */ .g) +var OAuth = (__nccwpck_require__(7511)/* .OAuth */ .f) +var hawk = __nccwpck_require__(2186) +var Multipart = (__nccwpck_require__(7261)/* .Multipart */ .$) +var Redirect = (__nccwpck_require__(5907)/* .Redirect */ .l) +var Tunnel = (__nccwpck_require__(673)/* .Tunnel */ .n) +var now = __nccwpck_require__(6860) +var Buffer = (__nccwpck_require__(9011).Buffer) +var inflate = __nccwpck_require__(5365) +var brotli = __nccwpck_require__(3522) +var urlParse = __nccwpck_require__(3534) var safeStringify = helpers.safeStringify var isReadStream = helpers.isReadStream var toBase64 = helpers.toBase64 @@ -39321,7 +40469,7 @@ module.exports = Request /***/ }), -/***/ 2665: +/***/ 4926: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -39598,7 +40746,7 @@ exports.isValid = function (domain) { /***/ }), -/***/ 4349: +/***/ 3566: /***/ ((module) => { "use strict"; @@ -39624,15 +40772,15 @@ module.exports = { /***/ }), -/***/ 7913: +/***/ 8680: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var stringify = __nccwpck_require__(6205); -var parse = __nccwpck_require__(2819); -var formats = __nccwpck_require__(4349); +var stringify = __nccwpck_require__(1738); +var parse = __nccwpck_require__(6700); +var formats = __nccwpck_require__(3566); module.exports = { formats: formats, @@ -39643,13 +40791,13 @@ module.exports = { /***/ }), -/***/ 2819: +/***/ 6700: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var utils = __nccwpck_require__(4939); +var utils = __nccwpck_require__(6987); var has = Object.prototype.hasOwnProperty; @@ -39826,14 +40974,14 @@ module.exports = function (str, opts) { /***/ }), -/***/ 6205: +/***/ 1738: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -var utils = __nccwpck_require__(4939); -var formats = __nccwpck_require__(4349); +var utils = __nccwpck_require__(6987); +var formats = __nccwpck_require__(3566); var arrayPrefixGenerators = { brackets: function brackets(prefix) { @@ -40051,7 +41199,7 @@ module.exports = function (object, opts) { /***/ }), -/***/ 4939: +/***/ 6987: /***/ ((module) => { "use strict"; @@ -40274,7 +41422,7 @@ module.exports = { /***/ }), -/***/ 3925: +/***/ 9011: /***/ ((module, exports, __nccwpck_require__) => { /*! safe-buffer. MIT License. Feross Aboukhadijeh */ @@ -40346,7 +41494,7 @@ SafeBuffer.allocUnsafeSlow = function (size) { /***/ }), -/***/ 5827: +/***/ 4217: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -40431,12 +41579,12 @@ module.exports = safer /***/ }), -/***/ 2008: +/***/ 2929: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. -var Buffer = (__nccwpck_require__(5827).Buffer); +var Buffer = (__nccwpck_require__(4217).Buffer); var algInfo = { 'dsa': { @@ -40606,30 +41754,30 @@ module.exports = { /***/ }), -/***/ 5085: +/***/ 934: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2016 Joyent, Inc. module.exports = Certificate; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var Fingerprint = __nccwpck_require__(7369); -var Signature = __nccwpck_require__(3616); -var errs = __nccwpck_require__(1395); +var Fingerprint = __nccwpck_require__(7294); +var Signature = __nccwpck_require__(3028); +var errs = __nccwpck_require__(4583); var util = __nccwpck_require__(3837); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var Identity = __nccwpck_require__(6070); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var Identity = __nccwpck_require__(5262); var formats = {}; -formats['openssh'] = __nccwpck_require__(8482); -formats['x509'] = __nccwpck_require__(9119); -formats['pem'] = __nccwpck_require__(7580); +formats['openssh'] = __nccwpck_require__(1336); +formats['x509'] = __nccwpck_require__(9163); +formats['pem'] = __nccwpck_require__(5651); var CertificateParseError = errs.CertificateParseError; var InvalidAlgorithmError = errs.InvalidAlgorithmError; @@ -41023,7 +42171,7 @@ Certificate._oldVersionDetect = function (obj) { /***/ }), -/***/ 3229: +/***/ 6963: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. @@ -41034,21 +42182,21 @@ module.exports = { generateED25519: generateED25519 }; -var assert = __nccwpck_require__(6381); +var assert = __nccwpck_require__(4500); var crypto = __nccwpck_require__(6113); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var nacl = __nccwpck_require__(8180); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var nacl = __nccwpck_require__(3465); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); var CRYPTO_HAVE_ECDH = (crypto.createECDH !== undefined); -var ecdh = __nccwpck_require__(7886); -var ec = __nccwpck_require__(5561); -var jsbn = (__nccwpck_require__(9778).BigInteger); +var ecdh = __nccwpck_require__(9838); +var ec = __nccwpck_require__(1220); +var jsbn = (__nccwpck_require__(484).BigInteger); function DiffieHellman(key) { utils.assertCompatible(key, Key, [1, 4], 'key'); @@ -41427,7 +42575,7 @@ function generateECDSA(curve) { /***/ }), -/***/ 751: +/***/ 3388: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -41437,12 +42585,12 @@ module.exports = { Signer: Signer }; -var nacl = __nccwpck_require__(8180); +var nacl = __nccwpck_require__(3465); var stream = __nccwpck_require__(2781); var util = __nccwpck_require__(3837); -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var Signature = __nccwpck_require__(3616); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var Signature = __nccwpck_require__(3028); function Verifier(key, hashAlgo) { if (hashAlgo.toLowerCase() !== 'sha512') @@ -41526,12 +42674,12 @@ Signer.prototype.sign = function () { /***/ }), -/***/ 1395: +/***/ 4583: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. -var assert = __nccwpck_require__(6381); +var assert = __nccwpck_require__(4500); var util = __nccwpck_require__(3837); function FingerprintFormatError(fp, format) { @@ -41617,22 +42765,22 @@ module.exports = { /***/ }), -/***/ 7369: +/***/ 7294: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. module.exports = Fingerprint; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var errs = __nccwpck_require__(1395); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var Certificate = __nccwpck_require__(5085); -var utils = __nccwpck_require__(9497); +var errs = __nccwpck_require__(4583); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var Certificate = __nccwpck_require__(934); +var utils = __nccwpck_require__(7890); var FingerprintFormatError = errs.FingerprintFormatError; var InvalidAlgorithmError = errs.InvalidAlgorithmError; @@ -41844,7 +42992,7 @@ Fingerprint._oldVersionDetect = function (obj) { /***/ }), -/***/ 7669: +/***/ 2372: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. @@ -41854,17 +43002,17 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); -var pem = __nccwpck_require__(5398); -var ssh = __nccwpck_require__(8745); -var rfc4253 = __nccwpck_require__(3909); -var dnssec = __nccwpck_require__(7727); -var putty = __nccwpck_require__(1548); +var pem = __nccwpck_require__(188); +var ssh = __nccwpck_require__(6847); +var rfc4253 = __nccwpck_require__(9677); +var dnssec = __nccwpck_require__(7455); +var putty = __nccwpck_require__(924); var DNSSEC_PRIVKEY_HEADER_PREFIX = 'Private-key-format: v1'; @@ -41975,7 +43123,7 @@ function write(key, options) { /***/ }), -/***/ 7727: +/***/ 7455: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. @@ -41985,13 +43133,13 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var utils = __nccwpck_require__(9497); -var SSHBuffer = __nccwpck_require__(9489); -var Dhe = __nccwpck_require__(3229); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var utils = __nccwpck_require__(7890); +var SSHBuffer = __nccwpck_require__(3095); +var Dhe = __nccwpck_require__(6963); var supportedAlgos = { 'rsa-sha1' : 5, @@ -42269,7 +43417,7 @@ function write(key, options) { /***/ }), -/***/ 8482: +/***/ 1336: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. @@ -42286,18 +43434,18 @@ module.exports = { toBuffer: toBuffer }; -var assert = __nccwpck_require__(6381); -var SSHBuffer = __nccwpck_require__(9489); +var assert = __nccwpck_require__(4500); +var SSHBuffer = __nccwpck_require__(3095); var crypto = __nccwpck_require__(6113); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var Identity = __nccwpck_require__(6070); -var rfc4253 = __nccwpck_require__(3909); -var Signature = __nccwpck_require__(3616); -var utils = __nccwpck_require__(9497); -var Certificate = __nccwpck_require__(5085); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var Identity = __nccwpck_require__(5262); +var rfc4253 = __nccwpck_require__(9677); +var Signature = __nccwpck_require__(3028); +var utils = __nccwpck_require__(7890); +var Certificate = __nccwpck_require__(934); function verify(cert, key) { /* @@ -42628,7 +43776,7 @@ function getCertType(key) { /***/ }), -/***/ 5398: +/***/ 188: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. @@ -42638,21 +43786,21 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); var crypto = __nccwpck_require__(6113); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); -var pkcs1 = __nccwpck_require__(9473); -var pkcs8 = __nccwpck_require__(3585); -var sshpriv = __nccwpck_require__(8523); -var rfc4253 = __nccwpck_require__(3909); +var pkcs1 = __nccwpck_require__(5787); +var pkcs8 = __nccwpck_require__(6929); +var sshpriv = __nccwpck_require__(9592); +var rfc4253 = __nccwpck_require__(9677); -var errors = __nccwpck_require__(1395); +var errors = __nccwpck_require__(4583); var OID_PBES2 = '1.2.840.113549.1.5.13'; var OID_PBKDF2 = '1.2.840.113549.1.5.12'; @@ -42925,7 +44073,7 @@ function write(key, options, type) { /***/ }), -/***/ 9473: +/***/ 5787: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -42937,17 +44085,17 @@ module.exports = { writePkcs1: writePkcs1 }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var pem = __nccwpck_require__(5398); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var pem = __nccwpck_require__(188); -var pkcs8 = __nccwpck_require__(3585); +var pkcs8 = __nccwpck_require__(6929); var readECDSACurve = pkcs8.readECDSACurve; function read(buf, options) { @@ -43305,7 +44453,7 @@ function writePkcs1EdDSAPublic(der, key) { /***/ }), -/***/ 3585: +/***/ 6929: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. @@ -43321,14 +44469,14 @@ module.exports = { writeECDSACurve: writeECDSACurve }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var pem = __nccwpck_require__(5398); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var pem = __nccwpck_require__(188); function read(buf, options) { return (pem.read(buf, options, 'pkcs8')); @@ -43943,7 +45091,7 @@ function writePkcs8EdDSAPrivate(key, der) { /***/ }), -/***/ 1548: +/***/ 924: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. @@ -43953,15 +45101,15 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var rfc4253 = __nccwpck_require__(3909); -var Key = __nccwpck_require__(9144); -var SSHBuffer = __nccwpck_require__(9489); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var rfc4253 = __nccwpck_require__(9677); +var Key = __nccwpck_require__(6974); +var SSHBuffer = __nccwpck_require__(3095); var crypto = __nccwpck_require__(6113); -var PrivateKey = __nccwpck_require__(5400); +var PrivateKey = __nccwpck_require__(7090); -var errors = __nccwpck_require__(1395); +var errors = __nccwpck_require__(4583); // https://tartarus.org/~simon/putty-prerel-snapshots/htmldoc/AppendixC.html function read(buf, options) { @@ -44144,7 +45292,7 @@ function wrap(txt, len) { /***/ }), -/***/ 3909: +/***/ 9677: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -44162,13 +45310,13 @@ module.exports = { algToKeyType: algToKeyType }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var SSHBuffer = __nccwpck_require__(9489); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var SSHBuffer = __nccwpck_require__(3095); function algToKeyType(alg) { assert.string(alg); @@ -44317,7 +45465,7 @@ function write(key, options) { /***/ }), -/***/ 8523: +/***/ 9592: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -44328,19 +45476,19 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); var crypto = __nccwpck_require__(6113); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var pem = __nccwpck_require__(5398); -var rfc4253 = __nccwpck_require__(3909); -var SSHBuffer = __nccwpck_require__(9489); -var errors = __nccwpck_require__(1395); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var pem = __nccwpck_require__(188); +var rfc4253 = __nccwpck_require__(9677); +var SSHBuffer = __nccwpck_require__(3095); +var errors = __nccwpck_require__(4583); var bcrypt; @@ -44389,7 +45537,7 @@ function readSSHPrivate(type, buf, options) { var rounds = kdfOptsBuf.readInt(); var cinf = utils.opensshCipherInfo(cipher); if (bcrypt === undefined) { - bcrypt = __nccwpck_require__(5634); + bcrypt = __nccwpck_require__(4972); } if (typeof (options.passphrase) === 'string') { @@ -44510,7 +45658,7 @@ function write(key, options) { kdfopts = kdfssh.toBuffer(); if (bcrypt === undefined) { - bcrypt = __nccwpck_require__(5634); + bcrypt = __nccwpck_require__(4972); } var pass = new Uint8Array(passphrase); var salti = new Uint8Array(salt); @@ -44586,7 +45734,7 @@ function write(key, options) { /***/ }), -/***/ 8745: +/***/ 6847: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -44596,14 +45744,14 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var rfc4253 = __nccwpck_require__(3909); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var rfc4253 = __nccwpck_require__(9677); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); -var sshpriv = __nccwpck_require__(8523); +var sshpriv = __nccwpck_require__(9592); /*JSSTYLED*/ var SSHKEY_RE = /^([a-z0-9-]+)[ \t]+([a-zA-Z0-9+\/]+[=]*)([ \t]+([^ \t][^\n]*[\n]*)?)?$/; @@ -44708,12 +45856,12 @@ function write(key, options) { /***/ }), -/***/ 7580: +/***/ 5651: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2016 Joyent, Inc. -var x509 = __nccwpck_require__(9119); +var x509 = __nccwpck_require__(9163); module.exports = { read: read, @@ -44722,17 +45870,17 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var pem = __nccwpck_require__(5398); -var Identity = __nccwpck_require__(6070); -var Signature = __nccwpck_require__(3616); -var Certificate = __nccwpck_require__(5085); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var pem = __nccwpck_require__(188); +var Identity = __nccwpck_require__(5262); +var Signature = __nccwpck_require__(3028); +var Certificate = __nccwpck_require__(934); function read(buf, options) { if (typeof (buf) !== 'string') { @@ -44803,7 +45951,7 @@ function write(cert, options) { /***/ }), -/***/ 9119: +/***/ 9163: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. @@ -44816,18 +45964,18 @@ module.exports = { write: write }; -var assert = __nccwpck_require__(6381); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); -var utils = __nccwpck_require__(9497); -var Key = __nccwpck_require__(9144); -var PrivateKey = __nccwpck_require__(5400); -var pem = __nccwpck_require__(5398); -var Identity = __nccwpck_require__(6070); -var Signature = __nccwpck_require__(3616); -var Certificate = __nccwpck_require__(5085); -var pkcs8 = __nccwpck_require__(3585); +var assert = __nccwpck_require__(4500); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); +var utils = __nccwpck_require__(7890); +var Key = __nccwpck_require__(6974); +var PrivateKey = __nccwpck_require__(7090); +var pem = __nccwpck_require__(188); +var Identity = __nccwpck_require__(5262); +var Signature = __nccwpck_require__(3028); +var Certificate = __nccwpck_require__(934); +var pkcs8 = __nccwpck_require__(6929); /* * This file is based on RFC5280 (X.509). @@ -45562,23 +46710,23 @@ function writeBitField(setBits, bitIndex) { /***/ }), -/***/ 6070: +/***/ 5262: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. module.exports = Identity; -var assert = __nccwpck_require__(6381); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var Fingerprint = __nccwpck_require__(7369); -var Signature = __nccwpck_require__(3616); -var errs = __nccwpck_require__(1395); +var Fingerprint = __nccwpck_require__(7294); +var Signature = __nccwpck_require__(3028); +var errs = __nccwpck_require__(4583); var util = __nccwpck_require__(3837); -var utils = __nccwpck_require__(9497); -var asn1 = __nccwpck_require__(687); -var Buffer = (__nccwpck_require__(5827).Buffer); +var utils = __nccwpck_require__(7890); +var asn1 = __nccwpck_require__(2141); +var Buffer = (__nccwpck_require__(4217).Buffer); /*JSSTYLED*/ var DNS_NAME_RE = /^([*]|[a-z0-9][a-z0-9\-]{0,62})(?:\.([*]|[a-z0-9][a-z0-9\-]{0,62}))*$/i; @@ -45942,18 +47090,18 @@ Identity._oldVersionDetect = function (obj) { /***/ }), -/***/ 7844: +/***/ 8720: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. -var Key = __nccwpck_require__(9144); -var Fingerprint = __nccwpck_require__(7369); -var Signature = __nccwpck_require__(3616); -var PrivateKey = __nccwpck_require__(5400); -var Certificate = __nccwpck_require__(5085); -var Identity = __nccwpck_require__(6070); -var errs = __nccwpck_require__(1395); +var Key = __nccwpck_require__(6974); +var Fingerprint = __nccwpck_require__(7294); +var Signature = __nccwpck_require__(3028); +var PrivateKey = __nccwpck_require__(7090); +var Certificate = __nccwpck_require__(934); +var Identity = __nccwpck_require__(5262); +var errs = __nccwpck_require__(4583); module.exports = { /* top-level classes */ @@ -45989,26 +47137,26 @@ module.exports = { /***/ }), -/***/ 9144: +/***/ 6974: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2018 Joyent, Inc. module.exports = Key; -var assert = __nccwpck_require__(6381); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var Fingerprint = __nccwpck_require__(7369); -var Signature = __nccwpck_require__(3616); -var DiffieHellman = (__nccwpck_require__(3229).DiffieHellman); -var errs = __nccwpck_require__(1395); -var utils = __nccwpck_require__(9497); -var PrivateKey = __nccwpck_require__(5400); +var Fingerprint = __nccwpck_require__(7294); +var Signature = __nccwpck_require__(3028); +var DiffieHellman = (__nccwpck_require__(6963).DiffieHellman); +var errs = __nccwpck_require__(4583); +var utils = __nccwpck_require__(7890); +var PrivateKey = __nccwpck_require__(7090); var edCompat; try { - edCompat = __nccwpck_require__(751); + edCompat = __nccwpck_require__(3388); } catch (e) { /* Just continue through, and bail out if we try to use it. */ } @@ -46017,16 +47165,16 @@ var InvalidAlgorithmError = errs.InvalidAlgorithmError; var KeyParseError = errs.KeyParseError; var formats = {}; -formats['auto'] = __nccwpck_require__(7669); -formats['pem'] = __nccwpck_require__(5398); -formats['pkcs1'] = __nccwpck_require__(9473); -formats['pkcs8'] = __nccwpck_require__(3585); -formats['rfc4253'] = __nccwpck_require__(3909); -formats['ssh'] = __nccwpck_require__(8745); -formats['ssh-private'] = __nccwpck_require__(8523); +formats['auto'] = __nccwpck_require__(2372); +formats['pem'] = __nccwpck_require__(188); +formats['pkcs1'] = __nccwpck_require__(5787); +formats['pkcs8'] = __nccwpck_require__(6929); +formats['rfc4253'] = __nccwpck_require__(9677); +formats['ssh'] = __nccwpck_require__(6847); +formats['ssh-private'] = __nccwpck_require__(9592); formats['openssh'] = formats['ssh-private']; -formats['dnssec'] = __nccwpck_require__(7727); -formats['putty'] = __nccwpck_require__(1548); +formats['dnssec'] = __nccwpck_require__(7455); +formats['putty'] = __nccwpck_require__(924); formats['ppk'] = formats['putty']; function Key(opts) { @@ -46290,45 +47438,45 @@ Key._oldVersionDetect = function (obj) { /***/ }), -/***/ 5400: +/***/ 7090: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2017 Joyent, Inc. module.exports = PrivateKey; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var Fingerprint = __nccwpck_require__(7369); -var Signature = __nccwpck_require__(3616); -var errs = __nccwpck_require__(1395); +var Fingerprint = __nccwpck_require__(7294); +var Signature = __nccwpck_require__(3028); +var errs = __nccwpck_require__(4583); var util = __nccwpck_require__(3837); -var utils = __nccwpck_require__(9497); -var dhe = __nccwpck_require__(3229); +var utils = __nccwpck_require__(7890); +var dhe = __nccwpck_require__(6963); var generateECDSA = dhe.generateECDSA; var generateED25519 = dhe.generateED25519; -var edCompat = __nccwpck_require__(751); -var nacl = __nccwpck_require__(8180); +var edCompat = __nccwpck_require__(3388); +var nacl = __nccwpck_require__(3465); -var Key = __nccwpck_require__(9144); +var Key = __nccwpck_require__(6974); var InvalidAlgorithmError = errs.InvalidAlgorithmError; var KeyParseError = errs.KeyParseError; var KeyEncryptedError = errs.KeyEncryptedError; var formats = {}; -formats['auto'] = __nccwpck_require__(7669); -formats['pem'] = __nccwpck_require__(5398); -formats['pkcs1'] = __nccwpck_require__(9473); -formats['pkcs8'] = __nccwpck_require__(3585); -formats['rfc4253'] = __nccwpck_require__(3909); -formats['ssh-private'] = __nccwpck_require__(8523); +formats['auto'] = __nccwpck_require__(2372); +formats['pem'] = __nccwpck_require__(188); +formats['pkcs1'] = __nccwpck_require__(5787); +formats['pkcs8'] = __nccwpck_require__(6929); +formats['rfc4253'] = __nccwpck_require__(9677); +formats['ssh-private'] = __nccwpck_require__(9592); formats['openssh'] = formats['ssh-private']; formats['ssh'] = formats['ssh-private']; -formats['dnssec'] = __nccwpck_require__(7727); -formats['putty'] = __nccwpck_require__(1548); +formats['dnssec'] = __nccwpck_require__(7455); +formats['putty'] = __nccwpck_require__(924); function PrivateKey(opts) { assert.object(opts, 'options'); @@ -46544,21 +47692,21 @@ PrivateKey._oldVersionDetect = function (obj) { /***/ }), -/***/ 3616: +/***/ 3028: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. module.exports = Signature; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var algs = __nccwpck_require__(2008); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var algs = __nccwpck_require__(2929); var crypto = __nccwpck_require__(6113); -var errs = __nccwpck_require__(1395); -var utils = __nccwpck_require__(9497); -var asn1 = __nccwpck_require__(687); -var SSHBuffer = __nccwpck_require__(9489); +var errs = __nccwpck_require__(4583); +var utils = __nccwpck_require__(7890); +var asn1 = __nccwpck_require__(2141); +var SSHBuffer = __nccwpck_require__(3095); var InvalidAlgorithmError = errs.InvalidAlgorithmError; var SignatureParseError = errs.SignatureParseError; @@ -46865,15 +48013,15 @@ Signature._oldVersionDetect = function (obj) { /***/ }), -/***/ 9489: +/***/ 3095: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. module.exports = SSHBuffer; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); function SSHBuffer(opts) { assert.object(opts, 'options'); @@ -47021,7 +48169,7 @@ SSHBuffer.prototype.write = function (buf) { /***/ }), -/***/ 9497: +/***/ 7890: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Copyright 2015 Joyent, Inc. @@ -47047,17 +48195,17 @@ module.exports = { pbkdf2: pbkdf2 }; -var assert = __nccwpck_require__(6381); -var Buffer = (__nccwpck_require__(5827).Buffer); -var PrivateKey = __nccwpck_require__(5400); -var Key = __nccwpck_require__(9144); +var assert = __nccwpck_require__(4500); +var Buffer = (__nccwpck_require__(4217).Buffer); +var PrivateKey = __nccwpck_require__(7090); +var Key = __nccwpck_require__(6974); var crypto = __nccwpck_require__(6113); -var algs = __nccwpck_require__(2008); -var asn1 = __nccwpck_require__(687); +var algs = __nccwpck_require__(2929); +var asn1 = __nccwpck_require__(2141); -var ec = __nccwpck_require__(5561); -var jsbn = (__nccwpck_require__(9778).BigInteger); -var nacl = __nccwpck_require__(8180); +var ec = __nccwpck_require__(1220); +var jsbn = (__nccwpck_require__(484).BigInteger); +var nacl = __nccwpck_require__(3465); var MAX_CLASS_DEPTH = 3; @@ -47432,20 +48580,20 @@ function opensshCipherInfo(cipher) { /***/ }), -/***/ 4321: +/***/ 9357: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(2852); +module.exports = __nccwpck_require__(2675); /***/ }), -/***/ 2852: +/***/ 2675: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var Promise, createRetrieverPromise, fs, nodeifyWrapper, retrieveBuffer, retrieveCombinedStream, retrieveCoreHttpStream, retrieveFilesystemStream, retrieveRequestHttpStream; -Promise = __nccwpck_require__(1857); +Promise = __nccwpck_require__(2195); fs = Promise.promisifyAll(__nccwpck_require__(7147)); @@ -47557,7 +48705,7 @@ module.exports = function(stream, options, callback) { /***/ }), -/***/ 7461: +/***/ 5197: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -47595,11 +48743,11 @@ module.exports = function(stream, options, callback) { var net = __nccwpck_require__(1808); var urlParse = (__nccwpck_require__(7310).parse); var util = __nccwpck_require__(3837); -var pubsuffix = __nccwpck_require__(477); -var Store = (__nccwpck_require__(9651)/* .Store */ .y); -var MemoryCookieStore = (__nccwpck_require__(5825)/* .MemoryCookieStore */ .m); -var pathMatch = (__nccwpck_require__(2481)/* .pathMatch */ .U); -var VERSION = __nccwpck_require__(1081); +var pubsuffix = __nccwpck_require__(8924); +var Store = (__nccwpck_require__(8406)/* .Store */ .y); +var MemoryCookieStore = (__nccwpck_require__(648)/* .MemoryCookieStore */ .m); +var pathMatch = (__nccwpck_require__(7641)/* .pathMatch */ .U); +var VERSION = __nccwpck_require__(2825); var punycode; try { @@ -49040,14 +50188,14 @@ exports.defaultPath = defaultPath; exports.pathMatch = pathMatch; exports.getPublicSuffix = pubsuffix.getPublicSuffix; exports.cookieCompare = cookieCompare; -exports.permuteDomain = __nccwpck_require__(1273).permuteDomain; +exports.permuteDomain = __nccwpck_require__(3813).permuteDomain; exports.permutePath = permutePath; exports.canonicalDomain = canonicalDomain; /***/ }), -/***/ 5825: +/***/ 648: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -49082,9 +50230,9 @@ exports.canonicalDomain = canonicalDomain; * POSSIBILITY OF SUCH DAMAGE. */ -var Store = (__nccwpck_require__(9651)/* .Store */ .y); -var permuteDomain = (__nccwpck_require__(1273).permuteDomain); -var pathMatch = (__nccwpck_require__(2481)/* .pathMatch */ .U); +var Store = (__nccwpck_require__(8406)/* .Store */ .y); +var permuteDomain = (__nccwpck_require__(3813).permuteDomain); +var pathMatch = (__nccwpck_require__(7641)/* .pathMatch */ .U); var util = __nccwpck_require__(3837); function MemoryCookieStore() { @@ -49236,7 +50384,7 @@ MemoryCookieStore.prototype.getAllCookies = function(cb) { /***/ }), -/***/ 2481: +/***/ 7641: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -49305,7 +50453,7 @@ exports.U = pathMatch; /***/ }), -/***/ 1273: +/***/ 3813: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -49340,7 +50488,7 @@ exports.U = pathMatch; * POSSIBILITY OF SUCH DAMAGE. */ -var pubsuffix = __nccwpck_require__(477); +var pubsuffix = __nccwpck_require__(8924); // Gives the permutation of all possible domainMatch()es of a given domain. The // array is in shortest-to-longest order. Handy for indexing. @@ -49369,7 +50517,7 @@ exports.permuteDomain = permuteDomain; /***/ }), -/***/ 477: +/***/ 8924: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -49404,7 +50552,7 @@ exports.permuteDomain = permuteDomain; * POSSIBILITY OF SUCH DAMAGE. */ -var psl = __nccwpck_require__(2665); +var psl = __nccwpck_require__(4926); function getPublicSuffix(domain) { return psl.get(domain); @@ -49415,7 +50563,7 @@ exports.getPublicSuffix = getPublicSuffix; /***/ }), -/***/ 9651: +/***/ 8406: /***/ ((__unused_webpack_module, exports) => { "use strict"; @@ -49498,7 +50646,7 @@ Store.prototype.getAllCookies = function(cb) { /***/ }), -/***/ 1081: +/***/ 2825: /***/ ((module) => { // generated by genversion @@ -49507,15 +50655,15 @@ module.exports = '2.5.0' /***/ }), -/***/ 586: +/***/ 5572: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = __nccwpck_require__(8526); +module.exports = __nccwpck_require__(8628); /***/ }), -/***/ 8526: +/***/ 8628: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; @@ -49787,7 +50935,7 @@ exports.debug = debug; // for test /***/ }), -/***/ 8180: +/***/ 3465: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { (function(nacl) { @@ -52182,7 +53330,7 @@ nacl.setPRNG = function(fn) { /***/ }), -/***/ 5165: +/***/ 374: /***/ (function(__unused_webpack_module, exports) { /** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */ @@ -53631,7 +54779,7 @@ Object.defineProperty(exports, '__esModule', { value: true }); /***/ }), -/***/ 2202: +/***/ 5098: /***/ ((module) => { /** @@ -53664,7 +54812,7 @@ module.exports = bytesToUuid; /***/ }), -/***/ 9261: +/***/ 9730: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { // Unique ID creation requires a high quality random # generator. In node.js @@ -53679,11 +54827,11 @@ module.exports = function nodeRNG() { /***/ }), -/***/ 5180: +/***/ 9470: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var rng = __nccwpck_require__(9261); -var bytesToUuid = __nccwpck_require__(2202); +var rng = __nccwpck_require__(9730); +var bytesToUuid = __nccwpck_require__(5098); function v4(options, buf, offset) { var i = buf && offset || 0; @@ -53715,18 +54863,18 @@ module.exports = v4; /***/ }), -/***/ 4862: +/***/ 1152: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { /* * verror.js: richer JavaScript errors */ -var mod_assertplus = __nccwpck_require__(6381); +var mod_assertplus = __nccwpck_require__(4500); var mod_util = __nccwpck_require__(3837); -var mod_extsprintf = __nccwpck_require__(5350); -var mod_isError = (__nccwpck_require__(9194)/* .isError */ .VZ); +var mod_extsprintf = __nccwpck_require__(6684); +var mod_isError = (__nccwpck_require__(4494)/* .isError */ .VZ); var sprintf = mod_extsprintf.sprintf; /* @@ -54534,8 +55682,8 @@ module.exports = JSON.parse('["ac","com.ac","edu.ac","gov.ac","net.ac","mil.ac", var __webpack_exports__ = {}; // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. (() => { -const core = __nccwpck_require__(4181); -var JiraApi = __nccwpck_require__(7871); +const core = __nccwpck_require__(7481); +var JiraApi = __nccwpck_require__(3949); try { const newVersion = core.getInput('tag'); diff --git a/dist/licenses.txt b/dist/licenses.txt index 5ee6a19..4797f3b 100644 --- a/dist/licenses.txt +++ b/dist/licenses.txt @@ -1480,25 +1480,13 @@ uuid MIT The MIT License (MIT) -Copyright (c) 2010-2016 Robert Kieffer and other contributors +Copyright (c) 2010-2020 Robert Kieffer and other contributors -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. verror