| require('./sourcemap-register.js');module.exports = |
| /******/ (() => { // webpackBootstrap |
| /******/ var __webpack_modules__ = ({ |
| |
| /***/ 7171: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __importDefault = (this && this.__importDefault) || function (mod) { |
| return (mod && mod.__esModule) ? mod : { "default": mod }; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.ArtifactProvider = void 0; |
| const core = __importStar(__nccwpck_require__(2186)); |
| const github = __importStar(__nccwpck_require__(5438)); |
| const adm_zip_1 = __importDefault(__nccwpck_require__(6761)); |
| const picomatch_1 = __importDefault(__nccwpck_require__(8569)); |
| const github_utils_1 = __nccwpck_require__(3522); |
| class ArtifactProvider { |
| constructor(octokit, artifact, name, pattern, sha, runId, token) { |
| this.octokit = octokit; |
| this.artifact = artifact; |
| this.name = name; |
| this.pattern = pattern; |
| this.sha = sha; |
| this.runId = runId; |
| this.token = token; |
| if (this.artifact.startsWith('/')) { |
| const endIndex = this.artifact.lastIndexOf('/'); |
| const rePattern = this.artifact.substring(1, endIndex); |
| const reOpts = this.artifact.substring(endIndex + 1); |
| const re = new RegExp(rePattern, reOpts); |
| this.artifactNameMatch = (str) => re.test(str); |
| this.getReportName = (str) => { |
| const match = str.match(re); |
| if (match === null) { |
| throw new Error(`Artifact name '${str}' does not match regex ${this.artifact}`); |
| } |
| let reportName = this.name; |
| for (let i = 1; i < match.length; i++) { |
| reportName = reportName.replace(new RegExp(`\\$${i}`, 'g'), match[i]); |
| } |
| return reportName; |
| }; |
| } |
| else { |
| this.artifactNameMatch = (str) => str === this.artifact; |
| this.getReportName = () => this.name; |
| } |
| this.fileNameMatch = picomatch_1.default(pattern); |
| } |
| async load() { |
| const result = {}; |
| const resp = await this.octokit.actions.listWorkflowRunArtifacts({ |
| ...github.context.repo, |
| run_id: this.runId, |
| per_page: 100 |
| }); |
| if (resp.data.artifacts.length === 0) { |
| core.warning(`No artifacts found in run ${this.runId}`); |
| return {}; |
| } |
| const artifacts = resp.data.artifacts.filter(a => this.artifactNameMatch(a.name)); |
| if (artifacts.length === 0) { |
| core.warning(`No artifact matches ${this.artifact}`); |
| return {}; |
| } |
| for (const art of artifacts) { |
| const fileName = `${art.name}.zip`; |
| await github_utils_1.downloadArtifact(this.octokit, art.id, fileName, this.token); |
| core.startGroup(`Reading archive ${fileName}`); |
| try { |
| const reportName = this.getReportName(art.name); |
| core.info(`Report name: ${reportName}`); |
| const files = []; |
| const zip = new adm_zip_1.default(fileName); |
| for (const entry of zip.getEntries()) { |
| const file = entry.entryName; |
| if (entry.isDirectory) { |
| core.info(`Skipping ${file}: entry is a directory`); |
| continue; |
| } |
| if (!this.fileNameMatch(file)) { |
| core.info(`Skipping ${file}: filename does not match pattern`); |
| continue; |
| } |
| const content = zip.readAsText(entry); |
| files.push({ file, content }); |
| core.info(`Read ${file}: ${content.length} chars`); |
| } |
| if (result[reportName]) { |
| result[reportName].push(...files); |
| } |
| else { |
| result[reportName] = files; |
| } |
| } |
| finally { |
| core.endGroup(); |
| } |
| } |
| return result; |
| } |
| async listTrackedFiles() { |
| return github_utils_1.listFiles(this.octokit, this.sha); |
| } |
| } |
| exports.ArtifactProvider = ArtifactProvider; |
| |
| |
| /***/ }), |
| |
| /***/ 9399: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __importDefault = (this && this.__importDefault) || function (mod) { |
| return (mod && mod.__esModule) ? mod : { "default": mod }; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.LocalFileProvider = void 0; |
| const fs = __importStar(__nccwpck_require__(5747)); |
| const fast_glob_1 = __importDefault(__nccwpck_require__(3664)); |
| const git_1 = __nccwpck_require__(9844); |
| class LocalFileProvider { |
| constructor(name, pattern) { |
| this.name = name; |
| this.pattern = pattern; |
| } |
| async load() { |
| const result = []; |
| for (const pat of this.pattern) { |
| const paths = await fast_glob_1.default(pat, { dot: true }); |
| for (const file of paths) { |
| const content = await fs.promises.readFile(file, { encoding: 'utf8' }); |
| result.push({ file, content }); |
| } |
| } |
| return { [this.name]: result }; |
| } |
| async listTrackedFiles() { |
| return git_1.listFiles(); |
| } |
| } |
| exports.LocalFileProvider = LocalFileProvider; |
| |
| |
| /***/ }), |
| |
| /***/ 3109: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const core = __importStar(__nccwpck_require__(2186)); |
| const github = __importStar(__nccwpck_require__(5438)); |
| const artifact_provider_1 = __nccwpck_require__(7171); |
| const local_file_provider_1 = __nccwpck_require__(9399); |
| const get_annotations_1 = __nccwpck_require__(5867); |
| const get_report_1 = __nccwpck_require__(3737); |
| const dart_json_parser_1 = __nccwpck_require__(4528); |
| const dotnet_trx_parser_1 = __nccwpck_require__(2664); |
| const java_junit_parser_1 = __nccwpck_require__(676); |
| const jest_junit_parser_1 = __nccwpck_require__(1113); |
| const mocha_json_parser_1 = __nccwpck_require__(6043); |
| const path_utils_1 = __nccwpck_require__(4070); |
| const github_utils_1 = __nccwpck_require__(3522); |
| const markdown_utils_1 = __nccwpck_require__(6482); |
| async function main() { |
| try { |
| const testReporter = new TestReporter(); |
| await testReporter.run(); |
| } |
| catch (error) { |
| core.setFailed(error.message); |
| } |
| } |
| class TestReporter { |
| constructor() { |
| this.artifact = core.getInput('artifact', { required: false }); |
| this.name = core.getInput('name', { required: true }); |
| this.path = core.getInput('path', { required: true }); |
| this.pathReplaceBackslashes = core.getInput('path-replace-backslashes', { required: false }) === 'true'; |
| this.reporter = core.getInput('reporter', { required: true }); |
| this.listSuites = core.getInput('list-suites', { required: true }); |
| this.listTests = core.getInput('list-tests', { required: true }); |
| this.maxAnnotations = parseInt(core.getInput('max-annotations', { required: true })); |
| this.failOnError = core.getInput('fail-on-error', { required: true }) === 'true'; |
| this.workDirInput = core.getInput('working-directory', { required: false }); |
| this.onlySummary = core.getInput('only-summary', { required: false }) === 'true'; |
| this.token = core.getInput('token', { required: true }); |
| this.context = github_utils_1.getCheckRunContext(); |
| this.octokit = github.getOctokit(this.token); |
| if (this.listSuites !== 'all' && this.listSuites !== 'failed') { |
| core.setFailed(`Input parameter 'list-suites' has invalid value`); |
| return; |
| } |
| if (this.listTests !== 'all' && this.listTests !== 'failed' && this.listTests !== 'none') { |
| core.setFailed(`Input parameter 'list-tests' has invalid value`); |
| return; |
| } |
| if (isNaN(this.maxAnnotations) || this.maxAnnotations < 0 || this.maxAnnotations > 50) { |
| core.setFailed(`Input parameter 'max-annotations' has invalid value`); |
| return; |
| } |
| } |
| async run() { |
| if (this.workDirInput) { |
| core.info(`Changing directory to '${this.workDirInput}'`); |
| process.chdir(this.workDirInput); |
| } |
| core.info(`Check runs will be created with SHA=${this.context.sha}`); |
| // Split path pattern by ',' and optionally convert all backslashes to forward slashes |
| // fast-glob (micromatch) always interprets backslashes as escape characters instead of directory separators |
| const pathsList = this.path.split(','); |
| const pattern = this.pathReplaceBackslashes ? pathsList.map(path_utils_1.normalizeFilePath) : pathsList; |
| const inputProvider = this.artifact |
| ? new artifact_provider_1.ArtifactProvider(this.octokit, this.artifact, this.name, pattern, this.context.sha, this.context.runId, this.token) |
| : new local_file_provider_1.LocalFileProvider(this.name, pattern); |
| const parseErrors = this.maxAnnotations > 0; |
| const trackedFiles = await inputProvider.listTrackedFiles(); |
| const workDir = this.artifact ? undefined : path_utils_1.normalizeDirPath(process.cwd(), true); |
| core.info(`Found ${trackedFiles.length} files tracked by GitHub`); |
| const options = { |
| workDir, |
| trackedFiles, |
| parseErrors |
| }; |
| core.info(`Using test report parser '${this.reporter}'`); |
| const parser = this.getParser(this.reporter, options); |
| const results = []; |
| const input = await inputProvider.load(); |
| for (const [reportName, files] of Object.entries(input)) { |
| try { |
| core.startGroup(`Creating test report ${reportName}`); |
| const tr = await this.createReport(parser, reportName, files); |
| results.push(...tr); |
| } |
| finally { |
| core.endGroup(); |
| } |
| } |
| const isFailed = results.some(tr => tr.result === 'failed'); |
| const conclusion = isFailed ? 'failure' : 'success'; |
| const passed = results.reduce((sum, tr) => sum + tr.passed, 0); |
| const failed = results.reduce((sum, tr) => sum + tr.failed, 0); |
| const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0); |
| const time = results.reduce((sum, tr) => sum + tr.time, 0); |
| core.setOutput('conclusion', conclusion); |
| core.setOutput('passed', passed); |
| core.setOutput('failed', failed); |
| core.setOutput('skipped', skipped); |
| core.setOutput('time', time); |
| if (this.failOnError && isFailed) { |
| core.setFailed(`Failed test were found and 'fail-on-error' option is set to ${this.failOnError}`); |
| return; |
| } |
| if (results.length === 0) { |
| core.setFailed(`No test report files were found`); |
| return; |
| } |
| } |
| async createReport(parser, name, files) { |
| if (files.length === 0) { |
| core.warning(`No file matches path ${this.path}`); |
| return []; |
| } |
| const results = []; |
| for (const { file, content } of files) { |
| core.info(`Processing test results from ${file}`); |
| const tr = await parser.parse(file, content); |
| results.push(tr); |
| } |
| core.info(`Creating check run ${name}`); |
| const createResp = await this.octokit.checks.create({ |
| head_sha: this.context.sha, |
| name, |
| status: 'in_progress', |
| output: { |
| title: name, |
| summary: '' |
| }, |
| ...github.context.repo |
| }); |
| core.info('Creating report summary'); |
| const { listSuites, listTests, onlySummary } = this; |
| const baseUrl = createResp.data.html_url; |
| const summary = get_report_1.getReport(results, { listSuites, listTests, baseUrl, onlySummary }); |
| core.info('Creating annotations'); |
| const annotations = get_annotations_1.getAnnotations(results, this.maxAnnotations); |
| const isFailed = results.some(tr => tr.result === 'failed'); |
| const conclusion = isFailed ? 'failure' : 'success'; |
| const icon = isFailed ? markdown_utils_1.Icon.fail : markdown_utils_1.Icon.success; |
| core.info(`Updating check run conclusion (${conclusion}) and output`); |
| const resp = await this.octokit.checks.update({ |
| check_run_id: createResp.data.id, |
| conclusion, |
| status: 'completed', |
| output: { |
| title: `${name} ${icon}`, |
| summary, |
| annotations |
| }, |
| ...github.context.repo |
| }); |
| core.info(`Check run create response: ${resp.status}`); |
| core.info(`Check run URL: ${resp.data.url}`); |
| core.info(`Check run HTML: ${resp.data.html_url}`); |
| return results; |
| } |
| getParser(reporter, options) { |
| switch (reporter) { |
| case 'dart-json': |
| return new dart_json_parser_1.DartJsonParser(options, 'dart'); |
| case 'dotnet-trx': |
| return new dotnet_trx_parser_1.DotnetTrxParser(options); |
| case 'flutter-json': |
| return new dart_json_parser_1.DartJsonParser(options, 'flutter'); |
| case 'java-junit': |
| return new java_junit_parser_1.JavaJunitParser(options); |
| case 'jest-junit': |
| return new jest_junit_parser_1.JestJunitParser(options); |
| case 'mocha-json': |
| return new mocha_json_parser_1.MochaJsonParser(options); |
| default: |
| throw new Error(`Input variable 'reporter' is set to invalid value '${reporter}'`); |
| } |
| } |
| } |
| main(); |
| |
| |
| /***/ }), |
| |
| /***/ 4528: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.DartJsonParser = void 0; |
| const path_utils_1 = __nccwpck_require__(4070); |
| const dart_json_types_1 = __nccwpck_require__(7887); |
| const test_results_1 = __nccwpck_require__(2768); |
| class TestRun { |
| constructor(path, suites, success, time) { |
| this.path = path; |
| this.suites = suites; |
| this.success = success; |
| this.time = time; |
| } |
| } |
| class TestSuite { |
| constructor(suite) { |
| this.suite = suite; |
| this.groups = {}; |
| } |
| } |
| class TestGroup { |
| constructor(group) { |
| this.group = group; |
| this.tests = []; |
| } |
| } |
| class TestCase { |
| constructor(testStart) { |
| this.testStart = testStart; |
| this.print = []; |
| this.groupId = testStart.test.groupIDs[testStart.test.groupIDs.length - 1]; |
| } |
| get result() { |
| var _a, _b, _c, _d; |
| if ((_a = this.testDone) === null || _a === void 0 ? void 0 : _a.skipped) { |
| return 'skipped'; |
| } |
| if (((_b = this.testDone) === null || _b === void 0 ? void 0 : _b.result) === 'success') { |
| return 'success'; |
| } |
| if (((_c = this.testDone) === null || _c === void 0 ? void 0 : _c.result) === 'error' || ((_d = this.testDone) === null || _d === void 0 ? void 0 : _d.result) === 'failure') { |
| return 'failed'; |
| } |
| return undefined; |
| } |
| get time() { |
| return this.testDone !== undefined ? this.testDone.time - this.testStart.time : 0; |
| } |
| } |
| class DartJsonParser { |
| constructor(options, sdk) { |
| this.options = options; |
| this.sdk = sdk; |
| } |
| async parse(path, content) { |
| const tr = this.getTestRun(path, content); |
| const result = this.getTestRunResult(tr); |
| return Promise.resolve(result); |
| } |
| getTestRun(path, content) { |
| const lines = content.split(/\n\r?/g); |
| const events = lines |
| .map((str, i) => { |
| if (str.trim() === '') { |
| return null; |
| } |
| try { |
| return JSON.parse(str); |
| } |
| catch (e) { |
| const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : ''; |
| throw new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`); |
| } |
| }) |
| .filter(evt => evt != null); |
| let success = false; |
| let totalTime = 0; |
| const suites = {}; |
| const tests = {}; |
| for (const evt of events) { |
| if (dart_json_types_1.isSuiteEvent(evt)) { |
| suites[evt.suite.id] = new TestSuite(evt.suite); |
| } |
| else if (dart_json_types_1.isGroupEvent(evt)) { |
| suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group); |
| } |
| else if (dart_json_types_1.isTestStartEvent(evt) && evt.test.url !== null) { |
| const test = new TestCase(evt); |
| const suite = suites[evt.test.suiteID]; |
| const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]]; |
| group.tests.push(test); |
| tests[evt.test.id] = test; |
| } |
| else if (dart_json_types_1.isTestDoneEvent(evt) && !evt.hidden && tests[evt.testID]) { |
| tests[evt.testID].testDone = evt; |
| } |
| else if (dart_json_types_1.isErrorEvent(evt) && tests[evt.testID]) { |
| tests[evt.testID].error = evt; |
| } |
| else if (dart_json_types_1.isMessageEvent(evt) && tests[evt.testID]) { |
| tests[evt.testID].print.push(evt); |
| } |
| else if (dart_json_types_1.isDoneEvent(evt)) { |
| success = evt.success; |
| totalTime = evt.time; |
| } |
| } |
| return new TestRun(path, Object.values(suites), success, totalTime); |
| } |
| getTestRunResult(tr) { |
| const suites = tr.suites.map(s => { |
| return new test_results_1.TestSuiteResult(this.getRelativePath(s.suite.path), this.getGroups(s)); |
| }); |
| return new test_results_1.TestRunResult(tr.path, suites, tr.time); |
| } |
| getGroups(suite) { |
| const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0); |
| groups.sort((a, b) => { var _a, _b; return ((_a = a.group.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.group.line) !== null && _b !== void 0 ? _b : 0); }); |
| return groups.map(group => { |
| group.tests.sort((a, b) => { var _a, _b; return ((_a = a.testStart.test.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.testStart.test.line) !== null && _b !== void 0 ? _b : 0); }); |
| const tests = group.tests.map(tc => { |
| const error = this.getError(suite, tc); |
| const testName = group.group.name !== undefined && tc.testStart.test.name.startsWith(group.group.name) |
| ? tc.testStart.test.name.slice(group.group.name.length).trim() |
| : tc.testStart.test.name.trim(); |
| return new test_results_1.TestCaseResult(testName, tc.result, tc.time, error); |
| }); |
| return new test_results_1.TestGroupResult(group.group.name, tests); |
| }); |
| } |
| getError(testSuite, test) { |
| var _a, _b, _c, _d, _e, _f; |
| if (!this.options.parseErrors || !test.error) { |
| return undefined; |
| } |
| const { trackedFiles } = this.options; |
| const stackTrace = (_b = (_a = test.error) === null || _a === void 0 ? void 0 : _a.stackTrace) !== null && _b !== void 0 ? _b : ''; |
| const print = test.print |
| .filter(p => p.messageType === 'print') |
| .map(p => p.message) |
| .join('\n'); |
| const details = [print, stackTrace].filter(str => str !== '').join('\n'); |
| const src = this.exceptionThrowSource(details, trackedFiles); |
| const message = this.getErrorMessage((_d = (_c = test.error) === null || _c === void 0 ? void 0 : _c.error) !== null && _d !== void 0 ? _d : '', print); |
| let path; |
| let line; |
| if (src !== undefined) { |
| path = src.path; |
| line = src.line; |
| } |
| else { |
| const testStartPath = this.getRelativePath(testSuite.suite.path); |
| if (trackedFiles.includes(testStartPath)) { |
| path = testStartPath; |
| line = (_f = (_e = test.testStart.test.root_line) !== null && _e !== void 0 ? _e : test.testStart.test.line) !== null && _f !== void 0 ? _f : undefined; |
| } |
| } |
| return { |
| path, |
| line, |
| message, |
| details |
| }; |
| } |
| getErrorMessage(message, print) { |
| if (this.sdk === 'flutter') { |
| const uselessMessageRe = /^Test failed\. See exception logs above\.\nThe test description was:/m; |
| const flutterPrintRe = /^══╡ EXCEPTION CAUGHT BY FLUTTER TEST FRAMEWORK ╞═+\s+(.*)\s+When the exception was thrown, this was the stack:/ms; |
| if (uselessMessageRe.test(message)) { |
| const match = print.match(flutterPrintRe); |
| if (match !== null) { |
| return match[1]; |
| } |
| } |
| } |
| return message || print; |
| } |
| exceptionThrowSource(ex, trackedFiles) { |
| const lines = ex.split(/\r?\n/g); |
| // regexp to extract file path and line number from stack trace |
| const dartRe = /^(?!package:)(.*)\s+(\d+):\d+\s+/; |
| const flutterRe = /^#\d+\s+.*\((?!package:)(.*):(\d+):\d+\)$/; |
| const re = this.sdk === 'dart' ? dartRe : flutterRe; |
| for (const str of lines) { |
| const match = str.match(re); |
| if (match !== null) { |
| const [_, pathStr, lineStr] = match; |
| const path = path_utils_1.normalizeFilePath(this.getRelativePath(pathStr)); |
| if (trackedFiles.includes(path)) { |
| const line = parseInt(lineStr); |
| return { path, line }; |
| } |
| } |
| } |
| } |
| getRelativePath(path) { |
| const prefix = 'file://'; |
| if (path.startsWith(prefix)) { |
| path = path.substr(prefix.length); |
| } |
| path = path_utils_1.normalizeFilePath(path); |
| const workDir = this.getWorkDir(path); |
| if (workDir !== undefined && path.startsWith(workDir)) { |
| path = path.substr(workDir.length); |
| } |
| return path; |
| } |
| getWorkDir(path) { |
| var _a, _b; |
| return ((_b = (_a = this.options.workDir) !== null && _a !== void 0 ? _a : this.assumedWorkDir) !== null && _b !== void 0 ? _b : (this.assumedWorkDir = path_utils_1.getBasePath(path, this.options.trackedFiles))); |
| } |
| } |
| exports.DartJsonParser = DartJsonParser; |
| |
| |
| /***/ }), |
| |
| /***/ 7887: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| /// reflects documentation at https://github.com/dart-lang/test/blob/master/pkgs/test/doc/json_reporter.md |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.isMessageEvent = exports.isDoneEvent = exports.isErrorEvent = exports.isTestDoneEvent = exports.isTestStartEvent = exports.isGroupEvent = exports.isSuiteEvent = void 0; |
| function isSuiteEvent(event) { |
| return event.type === 'suite'; |
| } |
| exports.isSuiteEvent = isSuiteEvent; |
| function isGroupEvent(event) { |
| return event.type === 'group'; |
| } |
| exports.isGroupEvent = isGroupEvent; |
| function isTestStartEvent(event) { |
| return event.type === 'testStart'; |
| } |
| exports.isTestStartEvent = isTestStartEvent; |
| function isTestDoneEvent(event) { |
| return event.type === 'testDone'; |
| } |
| exports.isTestDoneEvent = isTestDoneEvent; |
| function isErrorEvent(event) { |
| return event.type === 'error'; |
| } |
| exports.isErrorEvent = isErrorEvent; |
| function isDoneEvent(event) { |
| return event.type === 'done'; |
| } |
| exports.isDoneEvent = isDoneEvent; |
| function isMessageEvent(event) { |
| return event.type === 'print'; |
| } |
| exports.isMessageEvent = isMessageEvent; |
| |
| |
| /***/ }), |
| |
| /***/ 2664: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.DotnetTrxParser = void 0; |
| const xml2js_1 = __nccwpck_require__(6189); |
| const path_utils_1 = __nccwpck_require__(4070); |
| const parse_utils_1 = __nccwpck_require__(7811); |
| const test_results_1 = __nccwpck_require__(2768); |
| class TestClass { |
| constructor(name) { |
| this.name = name; |
| this.tests = []; |
| } |
| } |
| class Test { |
| constructor(name, outcome, duration, error) { |
| this.name = name; |
| this.outcome = outcome; |
| this.duration = duration; |
| this.error = error; |
| } |
| get result() { |
| switch (this.outcome) { |
| case 'Passed': |
| return 'success'; |
| case 'NotExecuted': |
| return 'skipped'; |
| case 'Failed': |
| return 'failed'; |
| } |
| } |
| } |
| class DotnetTrxParser { |
| constructor(options) { |
| this.options = options; |
| } |
| async parse(path, content) { |
| const trx = await this.getTrxReport(path, content); |
| const tc = this.getTestClasses(trx); |
| const tr = this.getTestRunResult(path, trx, tc); |
| tr.sort(true); |
| return tr; |
| } |
| async getTrxReport(path, content) { |
| try { |
| return (await xml2js_1.parseStringPromise(content)); |
| } |
| catch (e) { |
| throw new Error(`Invalid XML at ${path}\n\n${e}`); |
| } |
| } |
| getTestClasses(trx) { |
| if (trx.TestRun.TestDefinitions === undefined || trx.TestRun.Results === undefined) { |
| return []; |
| } |
| const unitTests = {}; |
| for (const td of trx.TestRun.TestDefinitions) { |
| for (const ut of td.UnitTest) { |
| unitTests[ut.$.id] = ut; |
| } |
| } |
| const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(result => ({ |
| result, |
| test: unitTests[result.$.testId] |
| })); |
| const testClasses = {}; |
| for (const r of unitTestsResults) { |
| const className = r.test.TestMethod[0].$.className; |
| let tc = testClasses[className]; |
| if (tc === undefined) { |
| tc = new TestClass(className); |
| testClasses[tc.name] = tc; |
| } |
| const error = this.getErrorInfo(r.result); |
| const durationAttr = r.result.$.duration; |
| const duration = durationAttr ? parse_utils_1.parseNetDuration(durationAttr) : 0; |
| const resultTestName = r.result.$.testName; |
| const testName = resultTestName.startsWith(className) && resultTestName[className.length] === '.' |
| ? resultTestName.substr(className.length + 1) |
| : resultTestName; |
| const test = new Test(testName, r.result.$.outcome, duration, error); |
| tc.tests.push(test); |
| } |
| const result = Object.values(testClasses); |
| return result; |
| } |
| getTestRunResult(path, trx, testClasses) { |
| const times = trx.TestRun.Times[0].$; |
| const totalTime = parse_utils_1.parseIsoDate(times.finish).getTime() - parse_utils_1.parseIsoDate(times.start).getTime(); |
| const suites = testClasses.map(testClass => { |
| const tests = testClass.tests.map(test => { |
| const error = this.getError(test); |
| return new test_results_1.TestCaseResult(test.name, test.result, test.duration, error); |
| }); |
| const group = new test_results_1.TestGroupResult(null, tests); |
| return new test_results_1.TestSuiteResult(testClass.name, [group]); |
| }); |
| return new test_results_1.TestRunResult(path, suites, totalTime); |
| } |
| getErrorInfo(testResult) { |
| var _a; |
| if (testResult.$.outcome !== 'Failed') { |
| return undefined; |
| } |
| const output = testResult.Output; |
| const error = (output === null || output === void 0 ? void 0 : output.length) > 0 && ((_a = output[0].ErrorInfo) === null || _a === void 0 ? void 0 : _a.length) > 0 ? output[0].ErrorInfo[0] : undefined; |
| return error; |
| } |
| getError(test) { |
| if (!this.options.parseErrors || !test.error) { |
| return undefined; |
| } |
| const error = test.error; |
| if (!Array.isArray(error.Message) || |
| error.Message.length === 0 || |
| !Array.isArray(error.StackTrace) || |
| error.StackTrace.length === 0) { |
| return undefined; |
| } |
| const message = test.error.Message[0]; |
| const stackTrace = test.error.StackTrace[0]; |
| let path; |
| let line; |
| const src = this.exceptionThrowSource(stackTrace); |
| if (src) { |
| path = src.path; |
| line = src.line; |
| } |
| return { |
| path, |
| line, |
| message, |
| details: `${message}\n${stackTrace}` |
| }; |
| } |
| exceptionThrowSource(stackTrace) { |
| const lines = stackTrace.split(/\r*\n/); |
| const re = / in (.+):line (\d+)$/; |
| const { trackedFiles } = this.options; |
| for (const str of lines) { |
| const match = str.match(re); |
| if (match !== null) { |
| const [_, fileStr, lineStr] = match; |
| const filePath = path_utils_1.normalizeFilePath(fileStr); |
| const workDir = this.getWorkDir(filePath); |
| if (workDir) { |
| const file = filePath.substr(workDir.length); |
| if (trackedFiles.includes(file)) { |
| const line = parseInt(lineStr); |
| return { path: file, line }; |
| } |
| } |
| } |
| } |
| } |
| getWorkDir(path) { |
| var _a, _b; |
| return ((_b = (_a = this.options.workDir) !== null && _a !== void 0 ? _a : this.assumedWorkDir) !== null && _b !== void 0 ? _b : (this.assumedWorkDir = path_utils_1.getBasePath(path, this.options.trackedFiles))); |
| } |
| } |
| exports.DotnetTrxParser = DotnetTrxParser; |
| |
| |
| /***/ }), |
| |
| /***/ 676: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.JavaJunitParser = void 0; |
| const path = __importStar(__nccwpck_require__(5622)); |
| const xml2js_1 = __nccwpck_require__(6189); |
| const path_utils_1 = __nccwpck_require__(4070); |
| const test_results_1 = __nccwpck_require__(2768); |
| class JavaJunitParser { |
| constructor(options) { |
| var _a; |
| this.options = options; |
| // Map to efficient lookup of all paths with given file name |
| this.trackedFiles = {}; |
| for (const filePath of options.trackedFiles) { |
| const fileName = path.basename(filePath); |
| const files = (_a = this.trackedFiles[fileName]) !== null && _a !== void 0 ? _a : (this.trackedFiles[fileName] = []); |
| files.push(path_utils_1.normalizeFilePath(filePath)); |
| } |
| } |
| async parse(filePath, content) { |
| const reportOrSuite = await this.getJunitReport(filePath, content); |
| const isReport = reportOrSuite.testsuites !== undefined; |
| // XML might contain: |
| // - multiple suites under <testsuites> root node |
| // - single <testsuite> as root node |
| let ju; |
| if (isReport) { |
| ju = reportOrSuite; |
| } |
| else { |
| // Make it behave the same way as if suite was inside <testsuites> root node |
| const suite = reportOrSuite.testsuite; |
| ju = { |
| testsuites: { |
| $: { time: suite.$.time }, |
| testsuite: [suite] |
| } |
| }; |
| } |
| return this.getTestRunResult(filePath, ju); |
| } |
| async getJunitReport(filePath, content) { |
| try { |
| return await xml2js_1.parseStringPromise(content); |
| } |
| catch (e) { |
| throw new Error(`Invalid XML at ${filePath}\n\n${e}`); |
| } |
| } |
| getTestRunResult(filePath, junit) { |
| var _a; |
| const suites = junit.testsuites.testsuite === undefined |
| ? [] |
| : junit.testsuites.testsuite.map(ts => { |
| const name = ts.$.name.trim(); |
| const time = parseFloat(ts.$.time) * 1000; |
| const sr = new test_results_1.TestSuiteResult(name, this.getGroups(ts), time); |
| return sr; |
| }); |
| const seconds = parseFloat((_a = junit.testsuites.$) === null || _a === void 0 ? void 0 : _a.time); |
| const time = isNaN(seconds) ? undefined : seconds * 1000; |
| return new test_results_1.TestRunResult(filePath, suites, time); |
| } |
| getGroups(suite) { |
| if (suite.testcase === undefined) { |
| return []; |
| } |
| const groups = []; |
| for (const tc of suite.testcase) { |
| // Normally classname is same as suite name - both refer to same Java class |
| // Therefore it doesn't make sense to process it as a group |
| // and tests will be added to default group with empty name |
| const className = tc.$.classname === suite.$.name ? '' : tc.$.classname; |
| let grp = groups.find(g => g.name === className); |
| if (grp === undefined) { |
| grp = { name: className, tests: [] }; |
| groups.push(grp); |
| } |
| grp.tests.push(tc); |
| } |
| return groups.map(grp => { |
| const tests = grp.tests.map(tc => { |
| const name = tc.$.name.trim(); |
| const result = this.getTestCaseResult(tc); |
| const time = parseFloat(tc.$.time) * 1000; |
| const error = this.getTestCaseError(tc); |
| return new test_results_1.TestCaseResult(name, result, time, error); |
| }); |
| return new test_results_1.TestGroupResult(grp.name, tests); |
| }); |
| } |
| getTestCaseResult(test) { |
| if (test.failure || test.error) |
| return 'failed'; |
| if (test.skipped) |
| return 'skipped'; |
| return 'success'; |
| } |
| getTestCaseError(tc) { |
| var _a; |
| if (!this.options.parseErrors) { |
| return undefined; |
| } |
| // We process <error> and <failure> the same way |
| const failures = (_a = tc.failure) !== null && _a !== void 0 ? _a : tc.error; |
| if (!failures) { |
| return undefined; |
| } |
| const failure = failures[0]; |
| const details = typeof failure === 'object' ? failure._ : failure; |
| let filePath; |
| let line; |
| const src = this.exceptionThrowSource(details); |
| if (src) { |
| filePath = src.filePath; |
| line = src.line; |
| } |
| return { |
| path: filePath, |
| line, |
| details, |
| message: typeof failure === 'object' ? failure.message : undefined |
| }; |
| } |
| exceptionThrowSource(stackTrace) { |
| const lines = stackTrace.split(/\r?\n/); |
| const re = /^at (.*)\((.*):(\d+)\)$/; |
| for (const str of lines) { |
| const match = str.match(re); |
| if (match !== null) { |
| const [_, tracePath, fileName, lineStr] = match; |
| const filePath = this.getFilePath(tracePath, fileName); |
| if (filePath !== undefined) { |
| const line = parseInt(lineStr); |
| return { filePath, line }; |
| } |
| } |
| } |
| } |
| // Stacktrace in Java doesn't contain full paths to source file. |
| // There are only package, file name and line. |
| // Assuming folder structure matches package name (as it should in Java), |
| // we can try to match tracked file. |
| getFilePath(tracePath, fileName) { |
| // Check if there is any tracked file with given name |
| const files = this.trackedFiles[fileName]; |
| if (files === undefined) { |
| return undefined; |
| } |
| // Remove class name and method name from trace. |
| // Take parts until first item with capital letter - package names are lowercase while class name is CamelCase. |
| const packageParts = tracePath.split(/\./g); |
| const packageIndex = packageParts.findIndex(part => part[0] <= 'Z'); |
| if (packageIndex !== -1) { |
| packageParts.splice(packageIndex, packageParts.length - packageIndex); |
| } |
| if (packageParts.length === 0) { |
| return undefined; |
| } |
| // Get right file |
| // - file name matches |
| // - parent folders structure must reflect the package name |
| for (const filePath of files) { |
| const dirs = path.dirname(filePath).split(/\//g); |
| if (packageParts.length > dirs.length) { |
| continue; |
| } |
| // get only N parent folders, where N = length of package name parts |
| if (dirs.length > packageParts.length) { |
| dirs.splice(0, dirs.length - packageParts.length); |
| } |
| // check if parent folder structure matches package name |
| const isMatch = packageParts.every((part, i) => part === dirs[i]); |
| if (isMatch) { |
| return filePath; |
| } |
| } |
| return undefined; |
| } |
| } |
| exports.JavaJunitParser = JavaJunitParser; |
| |
| |
| /***/ }), |
| |
| /***/ 1113: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.JestJunitParser = void 0; |
| const xml2js_1 = __nccwpck_require__(6189); |
| const node_utils_1 = __nccwpck_require__(5824); |
| const path_utils_1 = __nccwpck_require__(4070); |
| const test_results_1 = __nccwpck_require__(2768); |
| class JestJunitParser { |
| constructor(options) { |
| this.options = options; |
| } |
| async parse(path, content) { |
| const ju = await this.getJunitReport(path, content); |
| return this.getTestRunResult(path, ju); |
| } |
| async getJunitReport(path, content) { |
| try { |
| return (await xml2js_1.parseStringPromise(content)); |
| } |
| catch (e) { |
| throw new Error(`Invalid XML at ${path}\n\n${e}`); |
| } |
| } |
| getTestRunResult(path, junit) { |
| const suites = junit.testsuites.testsuite === undefined |
| ? [] |
| : junit.testsuites.testsuite.map(ts => { |
| const name = ts.$.name.trim(); |
| const time = parseFloat(ts.$.time) * 1000; |
| const sr = new test_results_1.TestSuiteResult(name, this.getGroups(ts), time); |
| return sr; |
| }); |
| const time = parseFloat(junit.testsuites.$.time) * 1000; |
| return new test_results_1.TestRunResult(path, suites, time); |
| } |
| getGroups(suite) { |
| const groups = []; |
| for (const tc of suite.testcase) { |
| let grp = groups.find(g => g.describe === tc.$.classname); |
| if (grp === undefined) { |
| grp = { describe: tc.$.classname, tests: [] }; |
| groups.push(grp); |
| } |
| grp.tests.push(tc); |
| } |
| return groups.map(grp => { |
| const tests = grp.tests.map(tc => { |
| const name = tc.$.name.trim(); |
| const result = this.getTestCaseResult(tc); |
| const time = parseFloat(tc.$.time) * 1000; |
| const error = this.getTestCaseError(tc); |
| return new test_results_1.TestCaseResult(name, result, time, error); |
| }); |
| return new test_results_1.TestGroupResult(grp.describe, tests); |
| }); |
| } |
| getTestCaseResult(test) { |
| if (test.failure) |
| return 'failed'; |
| if (test.skipped) |
| return 'skipped'; |
| return 'success'; |
| } |
| getTestCaseError(tc) { |
| if (!this.options.parseErrors || !tc.failure) { |
| return undefined; |
| } |
| const details = tc.failure[0]; |
| let path; |
| let line; |
| const src = node_utils_1.getExceptionSource(details, this.options.trackedFiles, file => this.getRelativePath(file)); |
| if (src) { |
| path = src.path; |
| line = src.line; |
| } |
| return { |
| path, |
| line, |
| details |
| }; |
| } |
| getRelativePath(path) { |
| path = path_utils_1.normalizeFilePath(path); |
| const workDir = this.getWorkDir(path); |
| if (workDir !== undefined && path.startsWith(workDir)) { |
| path = path.substr(workDir.length); |
| } |
| return path; |
| } |
| getWorkDir(path) { |
| var _a, _b; |
| return ((_b = (_a = this.options.workDir) !== null && _a !== void 0 ? _a : this.assumedWorkDir) !== null && _b !== void 0 ? _b : (this.assumedWorkDir = path_utils_1.getBasePath(path, this.options.trackedFiles))); |
| } |
| } |
| exports.JestJunitParser = JestJunitParser; |
| |
| |
| /***/ }), |
| |
| /***/ 6043: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.MochaJsonParser = void 0; |
| const test_results_1 = __nccwpck_require__(2768); |
| const node_utils_1 = __nccwpck_require__(5824); |
| const path_utils_1 = __nccwpck_require__(4070); |
| class MochaJsonParser { |
| constructor(options) { |
| this.options = options; |
| } |
| async parse(path, content) { |
| const mocha = this.getMochaJson(path, content); |
| const result = this.getTestRunResult(path, mocha); |
| result.sort(true); |
| return Promise.resolve(result); |
| } |
| getMochaJson(path, content) { |
| try { |
| return JSON.parse(content); |
| } |
| catch (e) { |
| throw new Error(`Invalid JSON at ${path}\n\n${e}`); |
| } |
| } |
| getTestRunResult(resultsPath, mocha) { |
| const suitesMap = {}; |
| const getSuite = (test) => { |
| var _a; |
| const path = this.getRelativePath(test.file); |
| return (_a = suitesMap[path]) !== null && _a !== void 0 ? _a : (suitesMap[path] = new test_results_1.TestSuiteResult(path, [])); |
| }; |
| for (const test of mocha.passes) { |
| const suite = getSuite(test); |
| this.processTest(suite, test, 'success'); |
| } |
| for (const test of mocha.failures) { |
| const suite = getSuite(test); |
| this.processTest(suite, test, 'failed'); |
| } |
| for (const test of mocha.pending) { |
| const suite = getSuite(test); |
| this.processTest(suite, test, 'skipped'); |
| } |
| const suites = Object.values(suitesMap); |
| return new test_results_1.TestRunResult(resultsPath, suites, mocha.stats.duration); |
| } |
| processTest(suite, test, result) { |
| var _a; |
| const groupName = test.fullTitle !== test.title |
| ? test.fullTitle.substr(0, test.fullTitle.length - test.title.length).trimEnd() |
| : null; |
| let group = suite.groups.find(grp => grp.name === groupName); |
| if (group === undefined) { |
| group = new test_results_1.TestGroupResult(groupName, []); |
| suite.groups.push(group); |
| } |
| const error = this.getTestCaseError(test); |
| const testCase = new test_results_1.TestCaseResult(test.title, result, (_a = test.duration) !== null && _a !== void 0 ? _a : 0, error); |
| group.tests.push(testCase); |
| } |
| getTestCaseError(test) { |
| const details = test.err.stack; |
| const message = test.err.message; |
| if (details === undefined) { |
| return undefined; |
| } |
| let path; |
| let line; |
| const src = node_utils_1.getExceptionSource(details, this.options.trackedFiles, file => this.getRelativePath(file)); |
| if (src) { |
| path = src.path; |
| line = src.line; |
| } |
| return { |
| path, |
| line, |
| message, |
| details |
| }; |
| } |
| getRelativePath(path) { |
| path = path_utils_1.normalizeFilePath(path); |
| const workDir = this.getWorkDir(path); |
| if (workDir !== undefined && path.startsWith(workDir)) { |
| path = path.substr(workDir.length); |
| } |
| return path; |
| } |
| getWorkDir(path) { |
| var _a, _b; |
| return ((_b = (_a = this.options.workDir) !== null && _a !== void 0 ? _a : this.assumedWorkDir) !== null && _b !== void 0 ? _b : (this.assumedWorkDir = path_utils_1.getBasePath(path, this.options.trackedFiles))); |
| } |
| } |
| exports.MochaJsonParser = MochaJsonParser; |
| |
| |
| /***/ }), |
| |
| /***/ 5867: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getAnnotations = void 0; |
| const markdown_utils_1 = __nccwpck_require__(6482); |
| const parse_utils_1 = __nccwpck_require__(7811); |
| function getAnnotations(results, maxCount) { |
| var _a, _b, _c, _d; |
| if (maxCount === 0) { |
| return []; |
| } |
| // Collect errors from TestRunResults |
| // Merge duplicates if there are more test results files processed |
| const errors = []; |
| const mergeDup = results.length > 1; |
| for (const tr of results) { |
| for (const ts of tr.suites) { |
| for (const tg of ts.groups) { |
| for (const tc of tg.tests) { |
| const err = tc.error; |
| if (err === undefined) { |
| continue; |
| } |
| const path = (_a = err.path) !== null && _a !== void 0 ? _a : tr.path; |
| const line = (_b = err.line) !== null && _b !== void 0 ? _b : 0; |
| if (mergeDup) { |
| const dup = errors.find(e => path === e.path && line === e.line && err.details === e.details); |
| if (dup !== undefined) { |
| dup.testRunPaths.push(tr.path); |
| continue; |
| } |
| } |
| errors.push({ |
| testRunPaths: [tr.path], |
| suiteName: ts.name, |
| testName: tg.name ? `${tg.name} ► ${tc.name}` : tc.name, |
| details: err.details, |
| message: (_d = (_c = err.message) !== null && _c !== void 0 ? _c : parse_utils_1.getFirstNonEmptyLine(err.details)) !== null && _d !== void 0 ? _d : 'Test failed', |
| path, |
| line |
| }); |
| } |
| } |
| } |
| } |
| // Limit number of created annotations |
| errors.splice(maxCount + 1); |
| const annotations = errors.map(e => { |
| const message = [ |
| 'Failed test found in:', |
| e.testRunPaths.map(p => ` ${p}`).join('\n'), |
| 'Error:', |
| ident(markdown_utils_1.fixEol(e.message), ' ') |
| ].join('\n'); |
| return enforceCheckRunLimits({ |
| path: e.path, |
| start_line: e.line, |
| end_line: e.line, |
| annotation_level: 'failure', |
| title: `${e.suiteName} ► ${e.testName}`, |
| raw_details: markdown_utils_1.fixEol(e.details), |
| message |
| }); |
| }); |
| return annotations; |
| } |
| exports.getAnnotations = getAnnotations; |
| function enforceCheckRunLimits(err) { |
| err.title = markdown_utils_1.ellipsis(err.title || '', 255); |
| err.message = markdown_utils_1.ellipsis(err.message, 65535); |
| if (err.raw_details) { |
| err.raw_details = markdown_utils_1.ellipsis(err.raw_details, 65535); |
| } |
| return err; |
| } |
| function ident(text, prefix) { |
| return text |
| .split(/\n/g) |
| .map(line => prefix + line) |
| .join('\n'); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 3737: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getReport = void 0; |
| const core = __importStar(__nccwpck_require__(2186)); |
| const markdown_utils_1 = __nccwpck_require__(6482); |
| const parse_utils_1 = __nccwpck_require__(7811); |
| const slugger_1 = __nccwpck_require__(3328); |
| const MAX_REPORT_LENGTH = 65535; |
| const defaultOptions = { |
| listSuites: 'all', |
| listTests: 'all', |
| baseUrl: '', |
| onlySummary: false |
| }; |
| function getReport(results, options = defaultOptions) { |
| core.info('Generating check run summary'); |
| applySort(results); |
| const opts = { ...options }; |
| let lines = renderReport(results, opts); |
| let report = lines.join('\n'); |
| if (getByteLength(report) <= MAX_REPORT_LENGTH) { |
| return report; |
| } |
| if (opts.listTests === 'all') { |
| core.info("Test report summary is too big - setting 'listTests' to 'failed'"); |
| opts.listTests = 'failed'; |
| lines = renderReport(results, opts); |
| report = lines.join('\n'); |
| if (getByteLength(report) <= MAX_REPORT_LENGTH) { |
| return report; |
| } |
| } |
| core.warning(`Test report summary exceeded limit of ${MAX_REPORT_LENGTH} bytes and will be trimmed`); |
| return trimReport(lines); |
| } |
| exports.getReport = getReport; |
| function trimReport(lines) { |
| const closingBlock = '```'; |
| const errorMsg = `**Report exceeded GitHub limit of ${MAX_REPORT_LENGTH} bytes and has been trimmed**`; |
| const maxErrorMsgLength = closingBlock.length + errorMsg.length + 2; |
| const maxReportLength = MAX_REPORT_LENGTH - maxErrorMsgLength; |
| let reportLength = 0; |
| let codeBlock = false; |
| let endLineIndex = 0; |
| for (endLineIndex = 0; endLineIndex < lines.length; endLineIndex++) { |
| const line = lines[endLineIndex]; |
| const lineLength = getByteLength(line); |
| reportLength += lineLength + 1; |
| if (reportLength > maxReportLength) { |
| break; |
| } |
| if (line === '```') { |
| codeBlock = !codeBlock; |
| } |
| } |
| const reportLines = lines.slice(0, endLineIndex); |
| if (codeBlock) { |
| reportLines.push('```'); |
| } |
| reportLines.push(errorMsg); |
| return reportLines.join('\n'); |
| } |
| function applySort(results) { |
| results.sort((a, b) => a.path.localeCompare(b.path)); |
| for (const res of results) { |
| res.suites.sort((a, b) => a.name.localeCompare(b.name)); |
| } |
| } |
| function getByteLength(text) { |
| return Buffer.byteLength(text, 'utf8'); |
| } |
| function renderReport(results, options) { |
| const sections = []; |
| const badge = getReportBadge(results); |
| sections.push(badge); |
| const runs = getTestRunsReport(results, options); |
| sections.push(...runs); |
| return sections; |
| } |
| function getReportBadge(results) { |
| const passed = results.reduce((sum, tr) => sum + tr.passed, 0); |
| const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0); |
| const failed = results.reduce((sum, tr) => sum + tr.failed, 0); |
| return getBadge(passed, failed, skipped); |
| } |
| function getBadge(passed, failed, skipped) { |
| const text = []; |
| if (passed > 0) { |
| text.push(`${passed} passed`); |
| } |
| if (failed > 0) { |
| text.push(`${failed} failed`); |
| } |
| if (skipped > 0) { |
| text.push(`${skipped} skipped`); |
| } |
| const message = text.length > 0 ? text.join(', ') : 'none'; |
| let color = 'success'; |
| if (failed > 0) { |
| color = 'critical'; |
| } |
| else if (passed === 0 && failed === 0) { |
| color = 'yellow'; |
| } |
| const hint = failed > 0 ? 'Tests failed' : 'Tests passed successfully'; |
| const uri = encodeURIComponent(`tests-${message}-${color}`); |
| return `![${hint}](https://img.shields.io/badge/${uri})`; |
| } |
| function getTestRunsReport(testRuns, options) { |
| const sections = []; |
| if (testRuns.length > 1 || options.onlySummary) { |
| const tableData = testRuns.map((tr, runIndex) => { |
| const time = markdown_utils_1.formatTime(tr.time); |
| const name = tr.path; |
| const addr = options.baseUrl + makeRunSlug(runIndex).link; |
| const nameLink = markdown_utils_1.link(name, addr); |
| const passed = tr.passed > 0 ? `${tr.passed}${markdown_utils_1.Icon.success}` : ''; |
| const failed = tr.failed > 0 ? `${tr.failed}${markdown_utils_1.Icon.fail}` : ''; |
| const skipped = tr.skipped > 0 ? `${tr.skipped}${markdown_utils_1.Icon.skip}` : ''; |
| return [nameLink, passed, failed, skipped, time]; |
| }); |
| const resultsTable = markdown_utils_1.table(['Report', 'Passed', 'Failed', 'Skipped', 'Time'], [markdown_utils_1.Align.Left, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right], ...tableData); |
| sections.push(resultsTable); |
| } |
| if (options.onlySummary === false) { |
| const suitesReports = testRuns.map((tr, i) => getSuitesReport(tr, i, options)).flat(); |
| sections.push(...suitesReports); |
| } |
| return sections; |
| } |
| function getSuitesReport(tr, runIndex, options) { |
| const sections = []; |
| const trSlug = makeRunSlug(runIndex); |
| const nameLink = `<a id="${trSlug.id}" href="${options.baseUrl + trSlug.link}">${tr.path}</a>`; |
| const icon = getResultIcon(tr.result); |
| sections.push(`## ${icon}\xa0${nameLink}`); |
| const time = markdown_utils_1.formatTime(tr.time); |
| const headingLine2 = tr.tests > 0 |
| ? `**${tr.tests}** tests were completed in **${time}** with **${tr.passed}** passed, **${tr.failed}** failed and **${tr.skipped}** skipped.` |
| : 'No tests found'; |
| sections.push(headingLine2); |
| const suites = options.listSuites === 'failed' ? tr.failedSuites : tr.suites; |
| if (suites.length > 0) { |
| const suitesTable = markdown_utils_1.table(['Test suite', 'Passed', 'Failed', 'Skipped', 'Time'], [markdown_utils_1.Align.Left, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right, markdown_utils_1.Align.Right], ...suites.map((s, suiteIndex) => { |
| const tsTime = markdown_utils_1.formatTime(s.time); |
| const tsName = s.name; |
| const skipLink = options.listTests === 'none' || (options.listTests === 'failed' && s.result !== 'failed'); |
| const tsAddr = options.baseUrl + makeSuiteSlug(runIndex, suiteIndex).link; |
| const tsNameLink = skipLink ? tsName : markdown_utils_1.link(tsName, tsAddr); |
| const passed = s.passed > 0 ? `${s.passed}${markdown_utils_1.Icon.success}` : ''; |
| const failed = s.failed > 0 ? `${s.failed}${markdown_utils_1.Icon.fail}` : ''; |
| const skipped = s.skipped > 0 ? `${s.skipped}${markdown_utils_1.Icon.skip}` : ''; |
| return [tsNameLink, passed, failed, skipped, tsTime]; |
| })); |
| sections.push(suitesTable); |
| } |
| if (options.listTests !== 'none') { |
| const tests = suites.map((ts, suiteIndex) => getTestsReport(ts, runIndex, suiteIndex, options)).flat(); |
| if (tests.length > 1) { |
| sections.push(...tests); |
| } |
| } |
| return sections; |
| } |
| function getTestsReport(ts, runIndex, suiteIndex, options) { |
| var _a, _b, _c; |
| if (options.listTests === 'failed' && ts.result !== 'failed') { |
| return []; |
| } |
| const groups = ts.groups; |
| if (groups.length === 0) { |
| return []; |
| } |
| const sections = []; |
| const tsName = ts.name; |
| const tsSlug = makeSuiteSlug(runIndex, suiteIndex); |
| const tsNameLink = `<a id="${tsSlug.id}" href="${options.baseUrl + tsSlug.link}">${tsName}</a>`; |
| const icon = getResultIcon(ts.result); |
| sections.push(`### ${icon}\xa0${tsNameLink}`); |
| sections.push('```'); |
| for (const grp of groups) { |
| if (grp.name) { |
| sections.push(grp.name); |
| } |
| const space = grp.name ? ' ' : ''; |
| for (const tc of grp.tests) { |
| const result = getResultIcon(tc.result); |
| sections.push(`${space}${result} ${tc.name}`); |
| if (tc.error) { |
| const lines = (_c = ((_a = tc.error.message) !== null && _a !== void 0 ? _a : (_b = parse_utils_1.getFirstNonEmptyLine(tc.error.details)) === null || _b === void 0 ? void 0 : _b.trim())) === null || _c === void 0 ? void 0 : _c.split(/\r?\n/g).map(l => '\t' + l); |
| if (lines) { |
| sections.push(...lines); |
| } |
| } |
| } |
| } |
| sections.push('```'); |
| return sections; |
| } |
| function makeRunSlug(runIndex) { |
| // use prefix to avoid slug conflicts after escaping the paths |
| return slugger_1.slug(`r${runIndex}`); |
| } |
| function makeSuiteSlug(runIndex, suiteIndex) { |
| // use prefix to avoid slug conflicts after escaping the paths |
| return slugger_1.slug(`r${runIndex}s${suiteIndex}`); |
| } |
| function getResultIcon(result) { |
| switch (result) { |
| case 'success': |
| return markdown_utils_1.Icon.success; |
| case 'skipped': |
| return markdown_utils_1.Icon.skip; |
| case 'failed': |
| return markdown_utils_1.Icon.fail; |
| default: |
| return ''; |
| } |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2768: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.TestCaseResult = exports.TestGroupResult = exports.TestSuiteResult = exports.TestRunResult = void 0; |
| class TestRunResult { |
| constructor(path, suites, totalTime) { |
| this.path = path; |
| this.suites = suites; |
| this.totalTime = totalTime; |
| } |
| get tests() { |
| return this.suites.reduce((sum, g) => sum + g.tests, 0); |
| } |
| get passed() { |
| return this.suites.reduce((sum, g) => sum + g.passed, 0); |
| } |
| get failed() { |
| return this.suites.reduce((sum, g) => sum + g.failed, 0); |
| } |
| get skipped() { |
| return this.suites.reduce((sum, g) => sum + g.skipped, 0); |
| } |
| get time() { |
| var _a; |
| return (_a = this.totalTime) !== null && _a !== void 0 ? _a : this.suites.reduce((sum, g) => sum + g.time, 0); |
| } |
| get result() { |
| return this.suites.some(t => t.result === 'failed') ? 'failed' : 'success'; |
| } |
| get failedSuites() { |
| return this.suites.filter(s => s.result === 'failed'); |
| } |
| sort(deep) { |
| this.suites.sort((a, b) => a.name.localeCompare(b.name)); |
| if (deep) { |
| for (const suite of this.suites) { |
| suite.sort(deep); |
| } |
| } |
| } |
| } |
| exports.TestRunResult = TestRunResult; |
| class TestSuiteResult { |
| constructor(name, groups, totalTime) { |
| this.name = name; |
| this.groups = groups; |
| this.totalTime = totalTime; |
| } |
| get tests() { |
| return this.groups.reduce((sum, g) => sum + g.tests.length, 0); |
| } |
| get passed() { |
| return this.groups.reduce((sum, g) => sum + g.passed, 0); |
| } |
| get failed() { |
| return this.groups.reduce((sum, g) => sum + g.failed, 0); |
| } |
| get skipped() { |
| return this.groups.reduce((sum, g) => sum + g.skipped, 0); |
| } |
| get time() { |
| var _a; |
| return (_a = this.totalTime) !== null && _a !== void 0 ? _a : this.groups.reduce((sum, g) => sum + g.time, 0); |
| } |
| get result() { |
| return this.groups.some(t => t.result === 'failed') ? 'failed' : 'success'; |
| } |
| get failedGroups() { |
| return this.groups.filter(grp => grp.result === 'failed'); |
| } |
| sort(deep) { |
| this.groups.sort((a, b) => { var _a, _b; return ((_a = a.name) !== null && _a !== void 0 ? _a : '').localeCompare((_b = b.name) !== null && _b !== void 0 ? _b : ''); }); |
| if (deep) { |
| for (const grp of this.groups) { |
| grp.sort(); |
| } |
| } |
| } |
| } |
| exports.TestSuiteResult = TestSuiteResult; |
| class TestGroupResult { |
| constructor(name, tests) { |
| this.name = name; |
| this.tests = tests; |
| } |
| get passed() { |
| return this.tests.reduce((sum, t) => (t.result === 'success' ? sum + 1 : sum), 0); |
| } |
| get failed() { |
| return this.tests.reduce((sum, t) => (t.result === 'failed' ? sum + 1 : sum), 0); |
| } |
| get skipped() { |
| return this.tests.reduce((sum, t) => (t.result === 'skipped' ? sum + 1 : sum), 0); |
| } |
| get time() { |
| return this.tests.reduce((sum, t) => sum + t.time, 0); |
| } |
| get result() { |
| return this.tests.some(t => t.result === 'failed') ? 'failed' : 'success'; |
| } |
| get failedTests() { |
| return this.tests.filter(tc => tc.result === 'failed'); |
| } |
| sort() { |
| this.tests.sort((a, b) => a.name.localeCompare(b.name)); |
| } |
| } |
| exports.TestGroupResult = TestGroupResult; |
| class TestCaseResult { |
| constructor(name, result, time, error) { |
| this.name = name; |
| this.result = result; |
| this.time = time; |
| this.error = error; |
| } |
| } |
| exports.TestCaseResult = TestCaseResult; |
| |
| |
| /***/ }), |
| |
| /***/ 6069: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const exec_1 = __nccwpck_require__(1514); |
| // Wraps original exec() function |
| // Returns exit code and whole stdout/stderr |
| async function exec(commandLine, args, options) { |
| options = options || {}; |
| let stdout = ''; |
| let stderr = ''; |
| options.listeners = { |
| stdout: (data) => (stdout += data.toString()), |
| stderr: (data) => (stderr += data.toString()) |
| }; |
| const code = await exec_1.exec(commandLine, args, options); |
| return { code, stdout, stderr }; |
| } |
| exports.default = exec; |
| |
| |
| /***/ }), |
| |
| /***/ 9844: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __importDefault = (this && this.__importDefault) || function (mod) { |
| return (mod && mod.__esModule) ? mod : { "default": mod }; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.listFiles = void 0; |
| const core = __importStar(__nccwpck_require__(2186)); |
| const exec_1 = __importDefault(__nccwpck_require__(6069)); |
| async function listFiles() { |
| core.startGroup('Listing all files tracked by git'); |
| let output = ''; |
| try { |
| output = (await exec_1.default('git', ['ls-files', '-z'])).stdout; |
| } |
| finally { |
| fixStdOutNullTermination(); |
| core.endGroup(); |
| } |
| return output.split('\u0000').filter(s => s.length > 0); |
| } |
| exports.listFiles = listFiles; |
| function fixStdOutNullTermination() { |
| // Previous command uses NULL as delimiters and output is printed to stdout. |
| // We have to make sure next thing written to stdout will start on new line. |
| // Otherwise things like ::set-output wouldn't work. |
| core.info(''); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 3522: |
| /***/ (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| var __importDefault = (this && this.__importDefault) || function (mod) { |
| return (mod && mod.__esModule) ? mod : { "default": mod }; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.listFiles = exports.downloadArtifact = exports.getCheckRunContext = void 0; |
| const fs_1 = __nccwpck_require__(5747); |
| const core = __importStar(__nccwpck_require__(2186)); |
| const github = __importStar(__nccwpck_require__(5438)); |
| const stream = __importStar(__nccwpck_require__(2413)); |
| const util_1 = __nccwpck_require__(1669); |
| const got_1 = __importDefault(__nccwpck_require__(3061)); |
| const asyncStream = util_1.promisify(stream.pipeline); |
| function getCheckRunContext() { |
| if (github.context.eventName === 'workflow_run') { |
| core.info('Action was triggered by workflow_run: using SHA and RUN_ID from triggering workflow'); |
| const event = github.context.payload; |
| if (!event.workflow_run) { |
| throw new Error("Event of type 'workflow_run' is missing 'workflow_run' field"); |
| } |
| return { |
| sha: event.workflow_run.head_commit.id, |
| runId: event.workflow_run.id |
| }; |
| } |
| const runId = github.context.runId; |
| if (github.context.payload.pull_request) { |
| core.info(`Action was triggered by ${github.context.eventName}: using SHA from head of source branch`); |
| const pr = github.context.payload.pull_request; |
| return { sha: pr.head.sha, runId }; |
| } |
| return { sha: github.context.sha, runId }; |
| } |
| exports.getCheckRunContext = getCheckRunContext; |
| async function downloadArtifact(octokit, artifactId, fileName, token) { |
| core.startGroup(`Downloading artifact ${fileName}`); |
| try { |
| core.info(`Artifact ID: ${artifactId}`); |
| const req = octokit.actions.downloadArtifact.endpoint({ |
| ...github.context.repo, |
| artifact_id: artifactId, |
| archive_format: 'zip' |
| }); |
| const headers = { |
| Authorization: `Bearer ${token}` |
| }; |
| const resp = await got_1.default(req.url, { |
| headers, |
| followRedirect: false |
| }); |
| core.info(`Fetch artifact URL: ${resp.statusCode} ${resp.statusMessage}`); |
| if (resp.statusCode !== 302) { |
| throw new Error('Fetch artifact URL failed: received unexpected status code'); |
| } |
| const url = resp.headers.location; |
| if (url === undefined) { |
| const receivedHeaders = Object.keys(resp.headers); |
| core.info(`Received headers: ${receivedHeaders.join(', ')}`); |
| throw new Error('Location header was not found in API response'); |
| } |
| if (typeof url !== 'string') { |
| throw new Error(`Location header has unexpected value: ${url}`); |
| } |
| const downloadStream = got_1.default.stream(url, { headers }); |
| const fileWriterStream = fs_1.createWriteStream(fileName); |
| core.info(`Downloading ${url}`); |
| downloadStream.on('downloadProgress', ({ transferred }) => { |
| core.info(`Progress: ${transferred} B`); |
| }); |
| await asyncStream(downloadStream, fileWriterStream); |
| } |
| finally { |
| core.endGroup(); |
| } |
| } |
| exports.downloadArtifact = downloadArtifact; |
| async function listFiles(octokit, sha) { |
| core.startGroup('Fetching list of tracked files from GitHub'); |
| try { |
| const commit = await octokit.git.getCommit({ |
| commit_sha: sha, |
| ...github.context.repo |
| }); |
| const files = await listGitTree(octokit, commit.data.tree.sha, ''); |
| return files; |
| } |
| finally { |
| core.endGroup(); |
| } |
| } |
| exports.listFiles = listFiles; |
| async function listGitTree(octokit, sha, path) { |
| const pathLog = path ? ` at ${path}` : ''; |
| core.info(`Fetching tree ${sha}${pathLog}`); |
| let truncated = false; |
| let tree = await octokit.git.getTree({ |
| recursive: 'true', |
| tree_sha: sha, |
| ...github.context.repo |
| }); |
| if (tree.data.truncated) { |
| truncated = true; |
| tree = await octokit.git.getTree({ |
| tree_sha: sha, |
| ...github.context.repo |
| }); |
| } |
| const result = []; |
| for (const tr of tree.data.tree) { |
| const file = `${path}${tr.path}`; |
| if (tr.type === 'blob') { |
| result.push(file); |
| } |
| else if (tr.type === 'tree' && truncated) { |
| const files = await listGitTree(octokit, tr.sha, `${file}/`); |
| result.push(...files); |
| } |
| } |
| return result; |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 6482: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.formatTime = exports.ellipsis = exports.fixEol = exports.tableEscape = exports.table = exports.link = exports.Icon = exports.Align = void 0; |
| var Align; |
| (function (Align) { |
| Align["Left"] = ":---"; |
| Align["Center"] = ":---:"; |
| Align["Right"] = "---:"; |
| Align["None"] = "---"; |
| })(Align = exports.Align || (exports.Align = {})); |
| exports.Icon = { |
| skip: '✖️', |
| success: '✔️', |
| fail: '❌' // ':x:' |
| }; |
| function link(title, address) { |
| return `[${title}](${address})`; |
| } |
| exports.link = link; |
| function table(headers, align, ...rows) { |
| const headerRow = `|${headers.map(tableEscape).join('|')}|`; |
| const alignRow = `|${align.join('|')}|`; |
| const contentRows = rows.map(row => `|${row.map(tableEscape).join('|')}|`).join('\n'); |
| return [headerRow, alignRow, contentRows].join('\n'); |
| } |
| exports.table = table; |
| function tableEscape(content) { |
| return content.toString().replace('|', '\\|'); |
| } |
| exports.tableEscape = tableEscape; |
| function fixEol(text) { |
| var _a; |
| return (_a = text === null || text === void 0 ? void 0 : text.replace(/\r/g, '')) !== null && _a !== void 0 ? _a : ''; |
| } |
| exports.fixEol = fixEol; |
| function ellipsis(text, maxLength) { |
| if (text.length <= maxLength) { |
| return text; |
| } |
| return text.substr(0, maxLength - 3) + '...'; |
| } |
| exports.ellipsis = ellipsis; |
| function formatTime(ms) { |
| if (ms > 1000) { |
| return `${Math.round(ms / 1000)}s`; |
| } |
| return `${Math.round(ms)}ms`; |
| } |
| exports.formatTime = formatTime; |
| |
| |
| /***/ }), |
| |
| /***/ 5824: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getExceptionSource = void 0; |
| const path_utils_1 = __nccwpck_require__(4070); |
| function getExceptionSource(stackTrace, trackedFiles, getRelativePath) { |
| const lines = stackTrace.split(/\r?\n/); |
| const re = /\((.*):(\d+):\d+\)$/; |
| for (const str of lines) { |
| const match = str.match(re); |
| if (match !== null) { |
| const [_, fileStr, lineStr] = match; |
| const filePath = path_utils_1.normalizeFilePath(fileStr); |
| if (filePath.startsWith('internal/') || filePath.includes('/node_modules/')) { |
| continue; |
| } |
| const path = getRelativePath(filePath); |
| if (!path) { |
| continue; |
| } |
| if (trackedFiles.includes(path)) { |
| const line = parseInt(lineStr); |
| return { path, line }; |
| } |
| } |
| } |
| } |
| exports.getExceptionSource = getExceptionSource; |
| |
| |
| /***/ }), |
| |
| /***/ 7811: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getFirstNonEmptyLine = exports.parseIsoDate = exports.parseNetDuration = void 0; |
| function parseNetDuration(str) { |
| const durationRe = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)$/; |
| const durationMatch = str.match(durationRe); |
| if (durationMatch === null) { |
| throw new Error(`Invalid format: "${str}" is not NET duration`); |
| } |
| const [_, hourStr, minStr, secStr] = durationMatch; |
| return (parseInt(hourStr) * 3600 + parseInt(minStr) * 60 + parseFloat(secStr)) * 1000; |
| } |
| exports.parseNetDuration = parseNetDuration; |
| function parseIsoDate(str) { |
| const isoDateRe = /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)$/; |
| if (str === undefined || !isoDateRe.test(str)) { |
| throw new Error(`Invalid format: "${str}" is not ISO date`); |
| } |
| return new Date(str); |
| } |
| exports.parseIsoDate = parseIsoDate; |
| function getFirstNonEmptyLine(stackTrace) { |
| const lines = stackTrace.split(/\r?\n/g); |
| return lines.find(str => !/^\s*$/.test(str)); |
| } |
| exports.getFirstNonEmptyLine = getFirstNonEmptyLine; |
| |
| |
| /***/ }), |
| |
| /***/ 4070: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getBasePath = exports.normalizeFilePath = exports.normalizeDirPath = void 0; |
| function normalizeDirPath(path, addTrailingSlash) { |
| if (!path) { |
| return path; |
| } |
| path = normalizeFilePath(path); |
| if (addTrailingSlash && !path.endsWith('/')) { |
| path += '/'; |
| } |
| return path; |
| } |
| exports.normalizeDirPath = normalizeDirPath; |
| function normalizeFilePath(path) { |
| if (!path) { |
| return path; |
| } |
| return path.trim().replace(/\\/g, '/'); |
| } |
| exports.normalizeFilePath = normalizeFilePath; |
| function getBasePath(path, trackedFiles) { |
| if (trackedFiles.includes(path)) { |
| return ''; |
| } |
| let max = ''; |
| for (const file of trackedFiles) { |
| if (path.endsWith(file) && file.length > max.length) { |
| max = file; |
| } |
| } |
| if (max === '') { |
| return undefined; |
| } |
| const base = path.substr(0, path.length - max.length); |
| return base; |
| } |
| exports.getBasePath = getBasePath; |
| |
| |
| /***/ }), |
| |
| /***/ 3328: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.slug = void 0; |
| // Returns HTML element id and href link usable as manual anchor links |
| // This is needed because Github in check run summary doesn't automatically |
| // create links out of headings as it normally does for other markdown content |
| function slug(name) { |
| const slugId = name |
| .trim() |
| .replace(/_/g, '') |
| .replace(/[./\\]/g, '-') |
| .replace(/[^\w-]/g, ''); |
| const id = `user-content-${slugId}`; |
| const link = `#${slugId}`; |
| return { id, link }; |
| } |
| exports.slug = slug; |
| |
| |
| /***/ }), |
| |
| /***/ 7351: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| "use strict"; |
| |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
| result["default"] = mod; |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const os = __importStar(__nccwpck_require__(2087)); |
| const utils_1 = __nccwpck_require__(5278); |
| /** |
| * Commands |
| * |
| * Command Format: |
| * ::name key=value,key=value::message |
| * |
| * Examples: |
| * ::warning::This is the message |
| * ::set-env name=MY_VAR::some value |
| */ |
| function issueCommand(command, properties, message) { |
| const cmd = new Command(command, properties, message); |
| process.stdout.write(cmd.toString() + os.EOL); |
| } |
| exports.issueCommand = issueCommand; |
| function issue(name, message = '') { |
| issueCommand(name, {}, message); |
| } |
| exports.issue = issue; |
| const CMD_STRING = '::'; |
| class Command { |
| constructor(command, properties, message) { |
| if (!command) { |
| command = 'missing.command'; |
| } |
| this.command = command; |
| this.properties = properties; |
| this.message = message; |
| } |
| toString() { |
| let cmdStr = CMD_STRING + this.command; |
| if (this.properties && Object.keys(this.properties).length > 0) { |
| cmdStr += ' '; |
| let first = true; |
| for (const key in this.properties) { |
| if (this.properties.hasOwnProperty(key)) { |
| const val = this.properties[key]; |
| if (val) { |
| if (first) { |
| first = false; |
| } |
| else { |
| cmdStr += ','; |
| } |
| cmdStr += `${key}=${escapeProperty(val)}`; |
| } |
| } |
| } |
| } |
| cmdStr += `${CMD_STRING}${escapeData(this.message)}`; |
| return cmdStr; |
| } |
| } |
| function escapeData(s) { |
| return utils_1.toCommandValue(s) |
| .replace(/%/g, '%25') |
| .replace(/\r/g, '%0D') |
| .replace(/\n/g, '%0A'); |
| } |
| function escapeProperty(s) { |
| return utils_1.toCommandValue(s) |
| .replace(/%/g, '%25') |
| .replace(/\r/g, '%0D') |
| .replace(/\n/g, '%0A') |
| .replace(/:/g, '%3A') |
| .replace(/,/g, '%2C'); |
| } |
| //# sourceMappingURL=command.js.map |
| |
| /***/ }), |
| |
| /***/ 2186: |
| /***/ (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()); |
| }); |
| }; |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
| result["default"] = mod; |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const command_1 = __nccwpck_require__(7351); |
| const file_command_1 = __nccwpck_require__(717); |
| const utils_1 = __nccwpck_require__(5278); |
| const os = __importStar(__nccwpck_require__(2087)); |
| const path = __importStar(__nccwpck_require__(5622)); |
| /** |
| * The code to exit an action |
| */ |
| var ExitCode; |
| (function (ExitCode) { |
| /** |
| * A code indicating that the action was successful |
| */ |
| ExitCode[ExitCode["Success"] = 0] = "Success"; |
| /** |
| * A code indicating that the action was a failure |
| */ |
| ExitCode[ExitCode["Failure"] = 1] = "Failure"; |
| })(ExitCode = exports.ExitCode || (exports.ExitCode = {})); |
| //----------------------------------------------------------------------- |
| // Variables |
| //----------------------------------------------------------------------- |
| /** |
| * Sets env variable for this action and future actions in the job |
| * @param name the name of the variable to set |
| * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function exportVariable(name, val) { |
| const convertedVal = utils_1.toCommandValue(val); |
| process.env[name] = convertedVal; |
| const filePath = process.env['GITHUB_ENV'] || ''; |
| if (filePath) { |
| 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); |
| } |
| } |
| exports.exportVariable = exportVariable; |
| /** |
| * Registers a secret which will get masked from logs |
| * @param secret value of the secret |
| */ |
| function setSecret(secret) { |
| command_1.issueCommand('add-mask', {}, secret); |
| } |
| exports.setSecret = setSecret; |
| /** |
| * Prepends inputPath to the PATH (for this action and future actions) |
| * @param inputPath |
| */ |
| function addPath(inputPath) { |
| const filePath = process.env['GITHUB_PATH'] || ''; |
| if (filePath) { |
| file_command_1.issueCommand('PATH', inputPath); |
| } |
| else { |
| command_1.issueCommand('add-path', {}, inputPath); |
| } |
| process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; |
| } |
| exports.addPath = addPath; |
| /** |
| * Gets the value of an input. The value is also trimmed. |
| * |
| * @param name name of the input to get |
| * @param options optional. See InputOptions. |
| * @returns string |
| */ |
| function getInput(name, options) { |
| const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; |
| if (options && options.required && !val) { |
| throw new Error(`Input required and not supplied: ${name}`); |
| } |
| return val.trim(); |
| } |
| exports.getInput = getInput; |
| /** |
| * Sets the value of an output. |
| * |
| * @param name name of the output to set |
| * @param value value to store. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function setOutput(name, value) { |
| command_1.issueCommand('set-output', { name }, value); |
| } |
| exports.setOutput = setOutput; |
| /** |
| * Enables or disables the echoing of commands into stdout for the rest of the step. |
| * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. |
| * |
| */ |
| function setCommandEcho(enabled) { |
| command_1.issue('echo', enabled ? 'on' : 'off'); |
| } |
| exports.setCommandEcho = setCommandEcho; |
| //----------------------------------------------------------------------- |
| // Results |
| //----------------------------------------------------------------------- |
| /** |
| * Sets the action status to failed. |
| * When the action exits it will be with an exit code of 1 |
| * @param message add error issue message |
| */ |
| function setFailed(message) { |
| process.exitCode = ExitCode.Failure; |
| error(message); |
| } |
| exports.setFailed = setFailed; |
| //----------------------------------------------------------------------- |
| // Logging Commands |
| //----------------------------------------------------------------------- |
| /** |
| * Gets whether Actions Step Debug is on or not |
| */ |
| function isDebug() { |
| return process.env['RUNNER_DEBUG'] === '1'; |
| } |
| exports.isDebug = isDebug; |
| /** |
| * Writes debug message to user log |
| * @param message debug message |
| */ |
| function debug(message) { |
| command_1.issueCommand('debug', {}, message); |
| } |
| exports.debug = debug; |
| /** |
| * Adds an error issue |
| * @param message error issue message. Errors will be converted to string via toString() |
| */ |
| function error(message) { |
| command_1.issue('error', message instanceof Error ? message.toString() : message); |
| } |
| exports.error = error; |
| /** |
| * Adds an warning issue |
| * @param message warning issue message. Errors will be converted to string via toString() |
| */ |
| function warning(message) { |
| command_1.issue('warning', message instanceof Error ? message.toString() : message); |
| } |
| exports.warning = warning; |
| /** |
| * Writes info to log with console.log. |
| * @param message info message |
| */ |
| function info(message) { |
| process.stdout.write(message + os.EOL); |
| } |
| exports.info = info; |
| /** |
| * Begin an output group. |
| * |
| * Output until the next `groupEnd` will be foldable in this group |
| * |
| * @param name The name of the output group |
| */ |
| function startGroup(name) { |
| command_1.issue('group', name); |
| } |
| exports.startGroup = startGroup; |
| /** |
| * End an output group. |
| */ |
| function endGroup() { |
| command_1.issue('endgroup'); |
| } |
| exports.endGroup = endGroup; |
| /** |
| * Wrap an asynchronous function call in a group. |
| * |
| * Returns the same type as the function itself. |
| * |
| * @param name The name of the group |
| * @param fn The function to wrap in the group |
| */ |
| function group(name, fn) { |
| return __awaiter(this, void 0, void 0, function* () { |
| startGroup(name); |
| let result; |
| try { |
| result = yield fn(); |
| } |
| finally { |
| endGroup(); |
| } |
| return result; |
| }); |
| } |
| exports.group = group; |
| //----------------------------------------------------------------------- |
| // Wrapper action state |
| //----------------------------------------------------------------------- |
| /** |
| * Saves state for current action, the state can only be retrieved by this action's post job execution. |
| * |
| * @param name name of the state to store |
| * @param value value to store. Non-string values will be converted to a string via JSON.stringify |
| */ |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any |
| function saveState(name, value) { |
| command_1.issueCommand('save-state', { name }, value); |
| } |
| exports.saveState = saveState; |
| /** |
| * Gets the value of an state set by this action's main execution. |
| * |
| * @param name name of the state to get |
| * @returns string |
| */ |
| function getState(name) { |
| return process.env[`STATE_${name}`] || ''; |
| } |
| exports.getState = getState; |
| //# sourceMappingURL=core.js.map |
| |
| /***/ }), |
| |
| /***/ 717: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| "use strict"; |
| |
| // For internal use, subject to change. |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
| result["default"] = mod; |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| // We use any as a valid input type |
| /* eslint-disable @typescript-eslint/no-explicit-any */ |
| const fs = __importStar(__nccwpck_require__(5747)); |
| const os = __importStar(__nccwpck_require__(2087)); |
| const utils_1 = __nccwpck_require__(5278); |
| function issueCommand(command, message) { |
| const filePath = process.env[`GITHUB_${command}`]; |
| if (!filePath) { |
| throw new Error(`Unable to find environment variable for file command ${command}`); |
| } |
| if (!fs.existsSync(filePath)) { |
| throw new Error(`Missing file at path: ${filePath}`); |
| } |
| fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { |
| encoding: 'utf8' |
| }); |
| } |
| exports.issueCommand = issueCommand; |
| //# sourceMappingURL=file-command.js.map |
| |
| /***/ }), |
| |
| /***/ 5278: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| // We use any as a valid input type |
| /* eslint-disable @typescript-eslint/no-explicit-any */ |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| /** |
| * Sanitizes an input into a string so it can be passed into issueCommand safely |
| * @param input input to sanitize into a string |
| */ |
| function toCommandValue(input) { |
| if (input === null || input === undefined) { |
| return ''; |
| } |
| else if (typeof input === 'string' || input instanceof String) { |
| return input; |
| } |
| return JSON.stringify(input); |
| } |
| exports.toCommandValue = toCommandValue; |
| //# sourceMappingURL=utils.js.map |
| |
| /***/ }), |
| |
| /***/ 1514: |
| /***/ (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()); |
| }); |
| }; |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
| result["default"] = mod; |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const tr = __importStar(__nccwpck_require__(8159)); |
| /** |
| * Exec a command. |
| * Output will be streamed to the live console. |
| * Returns promise with return code |
| * |
| * @param commandLine command to execute (can include additional args). Must be correctly escaped. |
| * @param args optional arguments for tool. Escaping is handled by the lib. |
| * @param options optional exec options. See ExecOptions |
| * @returns Promise<number> exit code |
| */ |
| function exec(commandLine, args, options) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const commandArgs = tr.argStringToArray(commandLine); |
| if (commandArgs.length === 0) { |
| throw new Error(`Parameter 'commandLine' cannot be null or empty.`); |
| } |
| // Path to tool to execute should be first arg |
| const toolPath = commandArgs[0]; |
| args = commandArgs.slice(1).concat(args || []); |
| const runner = new tr.ToolRunner(toolPath, args, options); |
| return runner.exec(); |
| }); |
| } |
| exports.exec = exec; |
| //# sourceMappingURL=exec.js.map |
| |
| /***/ }), |
| |
| /***/ 8159: |
| /***/ (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()); |
| }); |
| }; |
| var __importStar = (this && this.__importStar) || function (mod) { |
| if (mod && mod.__esModule) return mod; |
| var result = {}; |
| if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; |
| result["default"] = mod; |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const os = __importStar(__nccwpck_require__(2087)); |
| const events = __importStar(__nccwpck_require__(8614)); |
| const child = __importStar(__nccwpck_require__(3129)); |
| const path = __importStar(__nccwpck_require__(5622)); |
| const io = __importStar(__nccwpck_require__(7436)); |
| const ioUtil = __importStar(__nccwpck_require__(1962)); |
| /* eslint-disable @typescript-eslint/unbound-method */ |
| const IS_WINDOWS = process.platform === 'win32'; |
| /* |
| * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way. |
| */ |
| class ToolRunner extends events.EventEmitter { |
| constructor(toolPath, args, options) { |
| super(); |
| if (!toolPath) { |
| throw new Error("Parameter 'toolPath' cannot be null or empty."); |
| } |
| this.toolPath = toolPath; |
| this.args = args || []; |
| this.options = options || {}; |
| } |
| _debug(message) { |
| if (this.options.listeners && this.options.listeners.debug) { |
| this.options.listeners.debug(message); |
| } |
| } |
| _getCommandString(options, noPrefix) { |
| const toolPath = this._getSpawnFileName(); |
| const args = this._getSpawnArgs(options); |
| let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool |
| if (IS_WINDOWS) { |
| // Windows + cmd file |
| if (this._isCmdFile()) { |
| cmd += toolPath; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| // Windows + verbatim |
| else if (options.windowsVerbatimArguments) { |
| cmd += `"${toolPath}"`; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| // Windows (regular) |
| else { |
| cmd += this._windowsQuoteCmdArg(toolPath); |
| for (const a of args) { |
| cmd += ` ${this._windowsQuoteCmdArg(a)}`; |
| } |
| } |
| } |
| else { |
| // OSX/Linux - this can likely be improved with some form of quoting. |
| // creating processes on Unix is fundamentally different than Windows. |
| // on Unix, execvp() takes an arg array. |
| cmd += toolPath; |
| for (const a of args) { |
| cmd += ` ${a}`; |
| } |
| } |
| return cmd; |
| } |
| _processLineBuffer(data, strBuffer, onLine) { |
| try { |
| let s = strBuffer + data.toString(); |
| let n = s.indexOf(os.EOL); |
| while (n > -1) { |
| const line = s.substring(0, n); |
| onLine(line); |
| // the rest of the string ... |
| s = s.substring(n + os.EOL.length); |
| n = s.indexOf(os.EOL); |
| } |
| strBuffer = s; |
| } |
| catch (err) { |
| // streaming lines to console is best effort. Don't fail a build. |
| this._debug(`error processing line. Failed with error ${err}`); |
| } |
| } |
| _getSpawnFileName() { |
| if (IS_WINDOWS) { |
| if (this._isCmdFile()) { |
| return process.env['COMSPEC'] || 'cmd.exe'; |
| } |
| } |
| return this.toolPath; |
| } |
| _getSpawnArgs(options) { |
| if (IS_WINDOWS) { |
| if (this._isCmdFile()) { |
| let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; |
| for (const a of this.args) { |
| argline += ' '; |
| argline += options.windowsVerbatimArguments |
| ? a |
| : this._windowsQuoteCmdArg(a); |
| } |
| argline += '"'; |
| return [argline]; |
| } |
| } |
| return this.args; |
| } |
| _endsWith(str, end) { |
| return str.endsWith(end); |
| } |
| _isCmdFile() { |
| const upperToolPath = this.toolPath.toUpperCase(); |
| return (this._endsWith(upperToolPath, '.CMD') || |
| this._endsWith(upperToolPath, '.BAT')); |
| } |
| _windowsQuoteCmdArg(arg) { |
| // for .exe, apply the normal quoting rules that libuv applies |
| if (!this._isCmdFile()) { |
| return this._uvQuoteCmdArg(arg); |
| } |
| // otherwise apply quoting rules specific to the cmd.exe command line parser. |
| // the libuv rules are generic and are not designed specifically for cmd.exe |
| // command line parser. |
| // |
| // for a detailed description of the cmd.exe command line parser, refer to |
| // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912 |
| // need quotes for empty arg |
| if (!arg) { |
| return '""'; |
| } |
| // determine whether the arg needs to be quoted |
| const cmdSpecialChars = [ |
| ' ', |
| '\t', |
| '&', |
| '(', |
| ')', |
| '[', |
| ']', |
| '{', |
| '}', |
| '^', |
| '=', |
| ';', |
| '!', |
| "'", |
| '+', |
| ',', |
| '`', |
| '~', |
| '|', |
| '<', |
| '>', |
| '"' |
| ]; |
| let needsQuotes = false; |
| for (const char of arg) { |
| if (cmdSpecialChars.some(x => x === char)) { |
| needsQuotes = true; |
| break; |
| } |
| } |
| // short-circuit if quotes not needed |
| if (!needsQuotes) { |
| return arg; |
| } |
| // the following quoting rules are very similar to the rules that by libuv applies. |
| // |
| // 1) wrap the string in quotes |
| // |
| // 2) double-up quotes - i.e. " => "" |
| // |
| // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately |
| // doesn't work well with a cmd.exe command line. |
| // |
| // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app. |
| // for example, the command line: |
| // foo.exe "myarg:""my val""" |
| // is parsed by a .NET console app into an arg array: |
| // [ "myarg:\"my val\"" ] |
| // which is the same end result when applying libuv quoting rules. although the actual |
| // command line from libuv quoting rules would look like: |
| // foo.exe "myarg:\"my val\"" |
| // |
| // 3) double-up slashes that precede a quote, |
| // e.g. hello \world => "hello \world" |
| // hello\"world => "hello\\""world" |
| // hello\\"world => "hello\\\\""world" |
| // hello world\ => "hello world\\" |
| // |
| // technically this is not required for a cmd.exe command line, or the batch argument parser. |
| // the reasons for including this as a .cmd quoting rule are: |
| // |
| // a) this is optimized for the scenario where the argument is passed from the .cmd file to an |
| // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule. |
| // |
| // b) it's what we've been doing previously (by deferring to node default behavior) and we |
| // haven't heard any complaints about that aspect. |
| // |
| // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be |
| // escaped when used on the command line directly - even though within a .cmd file % can be escaped |
| // by using %%. |
| // |
| // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts |
| // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing. |
| // |
| // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would |
| // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the |
| // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args |
| // to an external program. |
| // |
| // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file. |
| // % can be escaped within a .cmd file. |
| let reverse = '"'; |
| let quoteHit = true; |
| for (let i = arg.length; i > 0; i--) { |
| // walk the string in reverse |
| reverse += arg[i - 1]; |
| if (quoteHit && arg[i - 1] === '\\') { |
| reverse += '\\'; // double the slash |
| } |
| else if (arg[i - 1] === '"') { |
| quoteHit = true; |
| reverse += '"'; // double the quote |
| } |
| else { |
| quoteHit = false; |
| } |
| } |
| reverse += '"'; |
| return reverse |
| .split('') |
| .reverse() |
| .join(''); |
| } |
| _uvQuoteCmdArg(arg) { |
| // Tool runner wraps child_process.spawn() and needs to apply the same quoting as |
| // Node in certain cases where the undocumented spawn option windowsVerbatimArguments |
| // is used. |
| // |
| // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV, |
| // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details), |
| // pasting copyright notice from Node within this function: |
| // |
| // Copyright Joyent, Inc. and other Node contributors. All rights reserved. |
| // |
| // 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 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. |
| if (!arg) { |
| // Need double quotation for empty argument |
| return '""'; |
| } |
| if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) { |
| // No quotation needed |
| return arg; |
| } |
| if (!arg.includes('"') && !arg.includes('\\')) { |
| // No embedded double quotes or backslashes, so I can just wrap |
| // quote marks around the whole thing. |
| return `"${arg}"`; |
| } |
| // Expected input/output: |
| // input : hello"world |
| // output: "hello\"world" |
| // input : hello""world |
| // output: "hello\"\"world" |
| // input : hello\world |
| // output: hello\world |
| // input : hello\\world |
| // output: hello\\world |
| // input : hello\"world |
| // output: "hello\\\"world" |
| // input : hello\\"world |
| // output: "hello\\\\\"world" |
| // input : hello world\ |
| // output: "hello world\\" - note the comment in libuv actually reads "hello world\" |
| // but it appears the comment is wrong, it should be "hello world\\" |
| let reverse = '"'; |
| let quoteHit = true; |
| for (let i = arg.length; i > 0; i--) { |
| // walk the string in reverse |
| reverse += arg[i - 1]; |
| if (quoteHit && arg[i - 1] === '\\') { |
| reverse += '\\'; |
| } |
| else if (arg[i - 1] === '"') { |
| quoteHit = true; |
| reverse += '\\'; |
| } |
| else { |
| quoteHit = false; |
| } |
| } |
| reverse += '"'; |
| return reverse |
| .split('') |
| .reverse() |
| .join(''); |
| } |
| _cloneExecOptions(options) { |
| options = options || {}; |
| const result = { |
| cwd: options.cwd || process.cwd(), |
| env: options.env || process.env, |
| silent: options.silent || false, |
| windowsVerbatimArguments: options.windowsVerbatimArguments || false, |
| failOnStdErr: options.failOnStdErr || false, |
| ignoreReturnCode: options.ignoreReturnCode || false, |
| delay: options.delay || 10000 |
| }; |
| result.outStream = options.outStream || process.stdout; |
| result.errStream = options.errStream || process.stderr; |
| return result; |
| } |
| _getSpawnOptions(options, toolPath) { |
| options = options || {}; |
| const result = {}; |
| result.cwd = options.cwd; |
| result.env = options.env; |
| result['windowsVerbatimArguments'] = |
| options.windowsVerbatimArguments || this._isCmdFile(); |
| if (options.windowsVerbatimArguments) { |
| result.argv0 = `"${toolPath}"`; |
| } |
| return result; |
| } |
| /** |
| * Exec a tool. |
| * Output will be streamed to the live console. |
| * Returns promise with return code |
| * |
| * @param tool path to tool to exec |
| * @param options optional exec options. See ExecOptions |
| * @returns number |
| */ |
| exec() { |
| return __awaiter(this, void 0, void 0, function* () { |
| // root the tool path if it is unrooted and contains relative pathing |
| if (!ioUtil.isRooted(this.toolPath) && |
| (this.toolPath.includes('/') || |
| (IS_WINDOWS && this.toolPath.includes('\\')))) { |
| // prefer options.cwd if it is specified, however options.cwd may also need to be rooted |
| this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); |
| } |
| // if the tool is only a file name, then resolve it from the PATH |
| // otherwise verify it exists (add extension on Windows if necessary) |
| this.toolPath = yield io.which(this.toolPath, true); |
| return new Promise((resolve, reject) => { |
| this._debug(`exec tool: ${this.toolPath}`); |
| this._debug('arguments:'); |
| for (const arg of this.args) { |
| this._debug(` ${arg}`); |
| } |
| const optionsNonNull = this._cloneExecOptions(this.options); |
| if (!optionsNonNull.silent && optionsNonNull.outStream) { |
| optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); |
| } |
| const state = new ExecState(optionsNonNull, this.toolPath); |
| state.on('debug', (message) => { |
| this._debug(message); |
| }); |
| const fileName = this._getSpawnFileName(); |
| const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); |
| const stdbuffer = ''; |
| if (cp.stdout) { |
| cp.stdout.on('data', (data) => { |
| if (this.options.listeners && this.options.listeners.stdout) { |
| this.options.listeners.stdout(data); |
| } |
| if (!optionsNonNull.silent && optionsNonNull.outStream) { |
| optionsNonNull.outStream.write(data); |
| } |
| this._processLineBuffer(data, stdbuffer, (line) => { |
| if (this.options.listeners && this.options.listeners.stdline) { |
| this.options.listeners.stdline(line); |
| } |
| }); |
| }); |
| } |
| const errbuffer = ''; |
| if (cp.stderr) { |
| cp.stderr.on('data', (data) => { |
| state.processStderr = true; |
| if (this.options.listeners && this.options.listeners.stderr) { |
| this.options.listeners.stderr(data); |
| } |
| if (!optionsNonNull.silent && |
| optionsNonNull.errStream && |
| optionsNonNull.outStream) { |
| const s = optionsNonNull.failOnStdErr |
| ? optionsNonNull.errStream |
| : optionsNonNull.outStream; |
| s.write(data); |
| } |
| this._processLineBuffer(data, errbuffer, (line) => { |
| if (this.options.listeners && this.options.listeners.errline) { |
| this.options.listeners.errline(line); |
| } |
| }); |
| }); |
| } |
| cp.on('error', (err) => { |
| state.processError = err.message; |
| state.processExited = true; |
| state.processClosed = true; |
| state.CheckComplete(); |
| }); |
| cp.on('exit', (code) => { |
| state.processExitCode = code; |
| state.processExited = true; |
| this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); |
| state.CheckComplete(); |
| }); |
| cp.on('close', (code) => { |
| state.processExitCode = code; |
| state.processExited = true; |
| state.processClosed = true; |
| this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); |
| state.CheckComplete(); |
| }); |
| state.on('done', (error, exitCode) => { |
| if (stdbuffer.length > 0) { |
| this.emit('stdline', stdbuffer); |
| } |
| if (errbuffer.length > 0) { |
| this.emit('errline', errbuffer); |
| } |
| cp.removeAllListeners(); |
| if (error) { |
| reject(error); |
| } |
| else { |
| resolve(exitCode); |
| } |
| }); |
| if (this.options.input) { |
| if (!cp.stdin) { |
| throw new Error('child process missing stdin'); |
| } |
| cp.stdin.end(this.options.input); |
| } |
| }); |
| }); |
| } |
| } |
| exports.ToolRunner = ToolRunner; |
| /** |
| * Convert an arg string to an array of args. Handles escaping |
| * |
| * @param argString string of arguments |
| * @returns string[] array of arguments |
| */ |
| function argStringToArray(argString) { |
| const args = []; |
| let inQuotes = false; |
| let escaped = false; |
| let arg = ''; |
| function append(c) { |
| // we only escape double quotes. |
| if (escaped && c !== '"') { |
| arg += '\\'; |
| } |
| arg += c; |
| escaped = false; |
| } |
| for (let i = 0; i < argString.length; i++) { |
| const c = argString.charAt(i); |
| if (c === '"') { |
| if (!escaped) { |
| inQuotes = !inQuotes; |
| } |
| else { |
| append(c); |
| } |
| continue; |
| } |
| if (c === '\\' && escaped) { |
| append(c); |
| continue; |
| } |
| if (c === '\\' && inQuotes) { |
| escaped = true; |
| continue; |
| } |
| if (c === ' ' && !inQuotes) { |
| if (arg.length > 0) { |
| args.push(arg); |
| arg = ''; |
| } |
| continue; |
| } |
| append(c); |
| } |
| if (arg.length > 0) { |
| args.push(arg.trim()); |
| } |
| return args; |
| } |
| exports.argStringToArray = argStringToArray; |
| class ExecState extends events.EventEmitter { |
| constructor(options, toolPath) { |
| super(); |
| this.processClosed = false; // tracks whether the process has exited and stdio is closed |
| this.processError = ''; |
| this.processExitCode = 0; |
| this.processExited = false; // tracks whether the process has exited |
| this.processStderr = false; // tracks whether stderr was written to |
| this.delay = 10000; // 10 seconds |
| this.done = false; |
| this.timeout = null; |
| if (!toolPath) { |
| throw new Error('toolPath must not be empty'); |
| } |
| this.options = options; |
| this.toolPath = toolPath; |
| if (options.delay) { |
| this.delay = options.delay; |
| } |
| } |
| CheckComplete() { |
| if (this.done) { |
| return; |
| } |
| if (this.processClosed) { |
| this._setResult(); |
| } |
| else if (this.processExited) { |
| this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this); |
| } |
| } |
| _debug(message) { |
| this.emit('debug', message); |
| } |
| _setResult() { |
| // determine whether there is an error |
| let error; |
| if (this.processExited) { |
| if (this.processError) { |
| error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); |
| } |
| else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { |
| error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); |
| } |
| else if (this.processStderr && this.options.failOnStdErr) { |
| error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); |
| } |
| } |
| // clear the timeout |
| if (this.timeout) { |
| clearTimeout(this.timeout); |
| this.timeout = null; |
| } |
| this.done = true; |
| this.emit('done', error, this.processExitCode); |
| } |
| static HandleTimeout(state) { |
| if (state.done) { |
| return; |
| } |
| if (!state.processClosed && state.processExited) { |
| const message = `The STDIO streams did not close within ${state.delay / |
| 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; |
| state._debug(message); |
| } |
| state._setResult(); |
| } |
| } |
| //# sourceMappingURL=toolrunner.js.map |
| |
| /***/ }), |
| |
| /***/ 4087: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.Context = void 0; |
| const fs_1 = __nccwpck_require__(5747); |
| const os_1 = __nccwpck_require__(2087); |
| class Context { |
| /** |
| * Hydrate the context from the environment |
| */ |
| constructor() { |
| this.payload = {}; |
| if (process.env.GITHUB_EVENT_PATH) { |
| if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) { |
| this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' })); |
| } |
| else { |
| const path = process.env.GITHUB_EVENT_PATH; |
| process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`); |
| } |
| } |
| this.eventName = process.env.GITHUB_EVENT_NAME; |
| this.sha = process.env.GITHUB_SHA; |
| this.ref = process.env.GITHUB_REF; |
| this.workflow = process.env.GITHUB_WORKFLOW; |
| this.action = process.env.GITHUB_ACTION; |
| this.actor = process.env.GITHUB_ACTOR; |
| this.job = process.env.GITHUB_JOB; |
| this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); |
| this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); |
| } |
| get issue() { |
| const payload = this.payload; |
| return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number }); |
| } |
| get repo() { |
| if (process.env.GITHUB_REPOSITORY) { |
| const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/'); |
| return { owner, repo }; |
| } |
| if (this.payload.repository) { |
| return { |
| owner: this.payload.repository.owner.login, |
| repo: this.payload.repository.name |
| }; |
| } |
| throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'"); |
| } |
| } |
| exports.Context = Context; |
| //# sourceMappingURL=context.js.map |
| |
| /***/ }), |
| |
| /***/ 5438: |
| /***/ (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getOctokit = exports.context = void 0; |
| const Context = __importStar(__nccwpck_require__(4087)); |
| const utils_1 = __nccwpck_require__(3030); |
| exports.context = new Context.Context(); |
| /** |
| * Returns a hydrated octokit ready to use for GitHub Actions |
| * |
| * @param token the repo PAT or GITHUB_TOKEN |
| * @param options other options to set |
| */ |
| function getOctokit(token, options) { |
| return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); |
| } |
| exports.getOctokit = getOctokit; |
| //# sourceMappingURL=github.js.map |
| |
| /***/ }), |
| |
| /***/ 7914: |
| /***/ (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0; |
| const httpClient = __importStar(__nccwpck_require__(9925)); |
| function getAuthString(token, options) { |
| if (!token && !options.auth) { |
| throw new Error('Parameter token or opts.auth is required'); |
| } |
| else if (token && options.auth) { |
| throw new Error('Parameters token and opts.auth may not both be specified'); |
| } |
| return typeof options.auth === 'string' ? options.auth : `token ${token}`; |
| } |
| exports.getAuthString = getAuthString; |
| function getProxyAgent(destinationUrl) { |
| const hc = new httpClient.HttpClient(); |
| return hc.getAgent(destinationUrl); |
| } |
| exports.getProxyAgent = getProxyAgent; |
| function getApiBaseUrl() { |
| return process.env['GITHUB_API_URL'] || 'https://api.github.com'; |
| } |
| exports.getApiBaseUrl = getApiBaseUrl; |
| //# sourceMappingURL=utils.js.map |
| |
| /***/ }), |
| |
| /***/ 3030: |
| /***/ (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| __setModuleDefault(result, mod); |
| return result; |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.getOctokitOptions = exports.GitHub = exports.context = void 0; |
| const Context = __importStar(__nccwpck_require__(4087)); |
| const Utils = __importStar(__nccwpck_require__(7914)); |
| // octokit + plugins |
| const core_1 = __nccwpck_require__(6762); |
| const plugin_rest_endpoint_methods_1 = __nccwpck_require__(3044); |
| const plugin_paginate_rest_1 = __nccwpck_require__(4193); |
| exports.context = new Context.Context(); |
| const baseUrl = Utils.getApiBaseUrl(); |
| const defaults = { |
| baseUrl, |
| request: { |
| agent: Utils.getProxyAgent(baseUrl) |
| } |
| }; |
| exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults); |
| /** |
| * Convience function to correctly format Octokit Options to pass into the constructor. |
| * |
| * @param token the repo PAT or GITHUB_TOKEN |
| * @param options other options to set |
| */ |
| function getOctokitOptions(token, options) { |
| const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller |
| // Auth |
| const auth = Utils.getAuthString(token, opts); |
| if (auth) { |
| opts.auth = auth; |
| } |
| return opts; |
| } |
| exports.getOctokitOptions = getOctokitOptions; |
| //# sourceMappingURL=utils.js.map |
| |
| /***/ }), |
| |
| /***/ 9925: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const http = __nccwpck_require__(8605); |
| const https = __nccwpck_require__(7211); |
| const pm = __nccwpck_require__(6443); |
| let tunnel; |
| var HttpCodes; |
| (function (HttpCodes) { |
| HttpCodes[HttpCodes["OK"] = 200] = "OK"; |
| HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; |
| HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; |
| HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; |
| HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; |
| HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; |
| HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; |
| HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; |
| HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; |
| HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; |
| HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; |
| HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; |
| HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; |
| HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; |
| HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; |
| HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; |
| HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; |
| HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; |
| HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; |
| HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; |
| HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; |
| HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; |
| HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; |
| HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; |
| HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; |
| HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; |
| HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; |
| })(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); |
| var Headers; |
| (function (Headers) { |
| Headers["Accept"] = "accept"; |
| Headers["ContentType"] = "content-type"; |
| })(Headers = exports.Headers || (exports.Headers = {})); |
| var MediaTypes; |
| (function (MediaTypes) { |
| MediaTypes["ApplicationJson"] = "application/json"; |
| })(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); |
| /** |
| * Returns the proxy URL, depending upon the supplied url and proxy environment variables. |
| * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com |
| */ |
| function getProxyUrl(serverUrl) { |
| let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); |
| return proxyUrl ? proxyUrl.href : ''; |
| } |
| exports.getProxyUrl = getProxyUrl; |
| const HttpRedirectCodes = [ |
| HttpCodes.MovedPermanently, |
| HttpCodes.ResourceMoved, |
| HttpCodes.SeeOther, |
| HttpCodes.TemporaryRedirect, |
| HttpCodes.PermanentRedirect |
| ]; |
| const HttpResponseRetryCodes = [ |
| HttpCodes.BadGateway, |
| HttpCodes.ServiceUnavailable, |
| HttpCodes.GatewayTimeout |
| ]; |
| const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; |
| const ExponentialBackoffCeiling = 10; |
| const ExponentialBackoffTimeSlice = 5; |
| class HttpClientError extends Error { |
| constructor(message, statusCode) { |
| super(message); |
| this.name = 'HttpClientError'; |
| this.statusCode = statusCode; |
| Object.setPrototypeOf(this, HttpClientError.prototype); |
| } |
| } |
| exports.HttpClientError = HttpClientError; |
| class HttpClientResponse { |
| constructor(message) { |
| this.message = message; |
| } |
| readBody() { |
| return 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()); |
| }); |
| }); |
| } |
| } |
| exports.HttpClientResponse = HttpClientResponse; |
| function isHttps(requestUrl) { |
| let parsedUrl = new URL(requestUrl); |
| return parsedUrl.protocol === 'https:'; |
| } |
| exports.isHttps = isHttps; |
| class HttpClient { |
| constructor(userAgent, handlers, requestOptions) { |
| this._ignoreSslError = false; |
| this._allowRedirects = true; |
| this._allowRedirectDowngrade = false; |
| this._maxRedirects = 50; |
| this._allowRetries = false; |
| this._maxRetries = 1; |
| this._keepAlive = false; |
| this._disposed = false; |
| this.userAgent = userAgent; |
| this.handlers = handlers || []; |
| this.requestOptions = requestOptions; |
| if (requestOptions) { |
| if (requestOptions.ignoreSslError != null) { |
| this._ignoreSslError = requestOptions.ignoreSslError; |
| } |
| this._socketTimeout = requestOptions.socketTimeout; |
| if (requestOptions.allowRedirects != null) { |
| this._allowRedirects = requestOptions.allowRedirects; |
| } |
| if (requestOptions.allowRedirectDowngrade != null) { |
| this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; |
| } |
| if (requestOptions.maxRedirects != null) { |
| this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); |
| } |
| if (requestOptions.keepAlive != null) { |
| this._keepAlive = requestOptions.keepAlive; |
| } |
| if (requestOptions.allowRetries != null) { |
| this._allowRetries = requestOptions.allowRetries; |
| } |
| if (requestOptions.maxRetries != null) { |
| this._maxRetries = requestOptions.maxRetries; |
| } |
| } |
| } |
| options(requestUrl, additionalHeaders) { |
| return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); |
| } |
| get(requestUrl, additionalHeaders) { |
| return this.request('GET', requestUrl, null, additionalHeaders || {}); |
| } |
| del(requestUrl, additionalHeaders) { |
| return this.request('DELETE', requestUrl, null, additionalHeaders || {}); |
| } |
| post(requestUrl, data, additionalHeaders) { |
| return this.request('POST', requestUrl, data, additionalHeaders || {}); |
| } |
| patch(requestUrl, data, additionalHeaders) { |
| return this.request('PATCH', requestUrl, data, additionalHeaders || {}); |
| } |
| put(requestUrl, data, additionalHeaders) { |
| return this.request('PUT', requestUrl, data, additionalHeaders || {}); |
| } |
| head(requestUrl, additionalHeaders) { |
| return this.request('HEAD', requestUrl, null, additionalHeaders || {}); |
| } |
| sendStream(verb, requestUrl, stream, additionalHeaders) { |
| 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); |
| } |
| /** |
| * 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; |
| } |
| } |
| if (authenticationHandler) { |
| return authenticationHandler.handleAuthentication(this, info, data); |
| } |
| else { |
| // We have received an unauthorized response but have no handlers to handle it. |
| // Let the response return to the caller. |
| return response; |
| } |
| } |
| let redirectsRemaining = this._maxRedirects; |
| while (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]; |
| } |
| } |
| } |
| // 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; |
| } |
| /** |
| * Needs to be called if keepAlive is set to true in request options. |
| */ |
| dispose() { |
| if (this._agent) { |
| this._agent.destroy(); |
| } |
| this._disposed = true; |
| } |
| /** |
| * Raw request. |
| * @param info |
| * @param data |
| */ |
| requestRaw(info, data) { |
| return new Promise((resolve, reject) => { |
| let callbackForResult = function (err, res) { |
| if (err) { |
| reject(err); |
| } |
| resolve(res); |
| }; |
| this.requestRawWithCallback(info, data, callbackForResult); |
| }); |
| } |
| /** |
| * Raw request with callback. |
| * @param info |
| * @param data |
| * @param onResult |
| */ |
| requestRawWithCallback(info, data, onResult) { |
| let socket; |
| if (typeof data === 'string') { |
| info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); |
| } |
| let callbackCalled = false; |
| let 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); |
| }); |
| req.on('socket', sock => { |
| socket = sock; |
| }); |
| // If we ever get disconnected, we want the socket to timeout eventually |
| req.setTimeout(this._socketTimeout || 3 * 60000, () => { |
| if (socket) { |
| socket.end(); |
| } |
| handleResult(new Error('Request timeout: ' + info.options.path), null); |
| }); |
| req.on('error', function (err) { |
| // err has statusCode property |
| // res should have headers |
| handleResult(err, null); |
| }); |
| if (data && typeof data === 'string') { |
| req.write(data, 'utf8'); |
| } |
| if (data && typeof data !== 'string') { |
| data.on('close', function () { |
| req.end(); |
| }); |
| data.pipe(req); |
| } |
| else { |
| req.end(); |
| } |
| } |
| /** |
| * Gets an http agent. This function is useful when you need an http agent that handles |
| * routing through a proxy server - depending upon the url and proxy environment variables. |
| * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com |
| */ |
| getAgent(serverUrl) { |
| let parsedUrl = new URL(serverUrl); |
| return this._getAgent(parsedUrl); |
| } |
| _prepareRequest(method, requestUrl, headers) { |
| const info = {}; |
| info.parsedUrl = requestUrl; |
| const usingSsl = info.parsedUrl.protocol === 'https:'; |
| info.httpModule = usingSsl ? https : http; |
| const defaultPort = usingSsl ? 443 : 80; |
| info.options = {}; |
| info.options.host = info.parsedUrl.hostname; |
| info.options.port = info.parsedUrl.port |
| ? parseInt(info.parsedUrl.port) |
| : defaultPort; |
| info.options.path = |
| (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); |
| info.options.method = method; |
| info.options.headers = this._mergeHeaders(headers); |
| if (this.userAgent != null) { |
| info.options.headers['user-agent'] = this.userAgent; |
| } |
| info.options.agent = this._getAgent(info.parsedUrl); |
| // gives handlers an opportunity to participate |
| if (this.handlers) { |
| this.handlers.forEach(handler => { |
| 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 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]; |
| } |
| return additionalHeaders[header] || clientHeader || _default; |
| } |
| _getAgent(parsedUrl) { |
| let agent; |
| let proxyUrl = pm.getProxyUrl(parsedUrl); |
| let useProxy = proxyUrl && proxyUrl.hostname; |
| if (this._keepAlive && useProxy) { |
| agent = this._proxyAgent; |
| } |
| if (this._keepAlive && !useProxy) { |
| agent = this._agent; |
| } |
| // if agent is already assigned use that agent. |
| if (!!agent) { |
| return agent; |
| } |
| const usingSsl = parsedUrl.protocol === 'https:'; |
| let maxSockets = 100; |
| if (!!this.requestOptions) { |
| maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; |
| } |
| if (useProxy) { |
| // If using proxy, need tunnel |
| if (!tunnel) { |
| tunnel = __nccwpck_require__(4294); |
| } |
| const agentOptions = { |
| maxSockets: maxSockets, |
| keepAlive: this._keepAlive, |
| proxy: { |
| proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`, |
| host: proxyUrl.hostname, |
| port: proxyUrl.port |
| } |
| }; |
| let tunnelAgent; |
| const overHttps = proxyUrl.protocol === 'https:'; |
| if (usingSsl) { |
| tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; |
| } |
| else { |
| tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; |
| } |
| agent = tunnelAgent(agentOptions); |
| this._proxyAgent = agent; |
| } |
| // if reusing agent across request and tunneling agent isn't assigned create a new agent |
| if (this._keepAlive && !agent) { |
| const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; |
| agent = usingSsl ? new https.Agent(options) : new http.Agent(options); |
| this._agent = agent; |
| } |
| // if not using private agent and tunnel agent isn't setup then use global agent |
| if (!agent) { |
| agent = usingSsl ? https.globalAgent : http.globalAgent; |
| } |
| if (usingSsl && this._ignoreSslError) { |
| // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process |
| // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options |
| // we have to cast it to any and change it directly |
| agent.options = Object.assign(agent.options || {}, { |
| rejectUnauthorized: false |
| }); |
| } |
| return agent; |
| } |
| _performExponentialBackoff(retryNumber) { |
| 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; |
| } |
| 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); |
| } |
| else { |
| obj = JSON.parse(contents); |
| } |
| response.result = obj; |
| } |
| response.headers = res.message.headers; |
| } |
| catch (err) { |
| // Invalid resource (contents not json); leaving result obj null |
| } |
| // note that 3xx redirects are handled by the http layer. |
| if (statusCode > 299) { |
| let msg; |
| // if exception/error in body, attempt to get better error |
| if (obj && obj.message) { |
| msg = obj.message; |
| } |
| else if (contents && contents.length > 0) { |
| // it may be the case that the exception is in the body message as string |
| msg = contents; |
| } |
| else { |
| msg = 'Failed request: (' + statusCode + ')'; |
| } |
| let err = new HttpClientError(msg, statusCode); |
| err.result = response.result; |
| reject(err); |
| } |
| else { |
| resolve(response); |
| } |
| }); |
| } |
| } |
| exports.HttpClient = HttpClient; |
| |
| |
| /***/ }), |
| |
| /***/ 6443: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| function getProxyUrl(reqUrl) { |
| let usingSsl = reqUrl.protocol === 'https:'; |
| let proxyUrl; |
| if (checkBypass(reqUrl)) { |
| return proxyUrl; |
| } |
| let proxyVar; |
| if (usingSsl) { |
| proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; |
| } |
| else { |
| proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; |
| } |
| if (proxyVar) { |
| proxyUrl = new URL(proxyVar); |
| } |
| return proxyUrl; |
| } |
| exports.getProxyUrl = getProxyUrl; |
| function checkBypass(reqUrl) { |
| if (!reqUrl.hostname) { |
| return false; |
| } |
| let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; |
| if (!noProxy) { |
| return false; |
| } |
| // Determine the request port |
| let reqPort; |
| if (reqUrl.port) { |
| reqPort = Number(reqUrl.port); |
| } |
| else if (reqUrl.protocol === 'http:') { |
| reqPort = 80; |
| } |
| else if (reqUrl.protocol === 'https:') { |
| reqPort = 443; |
| } |
| // Format the request hostname and hostname with port |
| let upperReqHosts = [reqUrl.hostname.toUpperCase()]; |
| if (typeof reqPort === 'number') { |
| upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); |
| } |
| // Compare request host against noproxy |
| for (let upperNoProxyItem of noProxy |
| .split(',') |
| .map(x => x.trim().toUpperCase()) |
| .filter(x => x)) { |
| if (upperReqHosts.some(x => x === upperNoProxyItem)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| exports.checkBypass = checkBypass; |
| |
| |
| /***/ }), |
| |
| /***/ 1962: |
| /***/ (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()); |
| }); |
| }; |
| var _a; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const assert_1 = __nccwpck_require__(2357); |
| const fs = __nccwpck_require__(5747); |
| const path = __nccwpck_require__(5622); |
| _a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink; |
| exports.IS_WINDOWS = process.platform === 'win32'; |
| function exists(fsPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| try { |
| yield exports.stat(fsPath); |
| } |
| catch (err) { |
| if (err.code === 'ENOENT') { |
| return false; |
| } |
| throw err; |
| } |
| return true; |
| }); |
| } |
| exports.exists = exists; |
| function isDirectory(fsPath, useStat = false) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath); |
| return stats.isDirectory(); |
| }); |
| } |
| exports.isDirectory = isDirectory; |
| /** |
| * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like: |
| * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases). |
| */ |
| function isRooted(p) { |
| p = normalizeSeparators(p); |
| if (!p) { |
| throw new Error('isRooted() parameter "p" cannot be empty'); |
| } |
| if (exports.IS_WINDOWS) { |
| return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello |
| ); // e.g. C: or C:\hello |
| } |
| return p.startsWith('/'); |
| } |
| exports.isRooted = isRooted; |
| /** |
| * Recursively create a directory at `fsPath`. |
| * |
| * This implementation is optimistic, meaning it attempts to create the full |
| * path first, and backs up the path stack from there. |
| * |
| * @param fsPath The path to create |
| * @param maxDepth The maximum recursion depth |
| * @param depth The current recursion depth |
| */ |
| function mkdirP(fsPath, maxDepth = 1000, depth = 1) { |
| return __awaiter(this, void 0, void 0, function* () { |
| assert_1.ok(fsPath, 'a path argument must be provided'); |
| fsPath = path.resolve(fsPath); |
| if (depth >= maxDepth) |
| return exports.mkdir(fsPath); |
| try { |
| yield exports.mkdir(fsPath); |
| return; |
| } |
| catch (err) { |
| switch (err.code) { |
| case 'ENOENT': { |
| yield mkdirP(path.dirname(fsPath), maxDepth, depth + 1); |
| yield exports.mkdir(fsPath); |
| return; |
| } |
| default: { |
| let stats; |
| try { |
| stats = yield exports.stat(fsPath); |
| } |
| catch (err2) { |
| throw err; |
| } |
| if (!stats.isDirectory()) |
| throw err; |
| } |
| } |
| } |
| }); |
| } |
| exports.mkdirP = mkdirP; |
| /** |
| * Best effort attempt to determine whether a file exists and is executable. |
| * @param filePath file path to check |
| * @param extensions additional file extensions to try |
| * @return if file exists and is executable, returns the file path. otherwise empty string. |
| */ |
| function tryGetExecutablePath(filePath, extensions) { |
| return __awaiter(this, void 0, void 0, function* () { |
| let stats = undefined; |
| try { |
| // test file exists |
| stats = yield exports.stat(filePath); |
| } |
| catch (err) { |
| if (err.code !== 'ENOENT') { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); |
| } |
| } |
| if (stats && stats.isFile()) { |
| if (exports.IS_WINDOWS) { |
| // on Windows, test for valid extension |
| const upperExt = path.extname(filePath).toUpperCase(); |
| if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) { |
| return filePath; |
| } |
| } |
| else { |
| if (isUnixExecutable(stats)) { |
| return filePath; |
| } |
| } |
| } |
| // try each extension |
| const originalFilePath = filePath; |
| for (const extension of extensions) { |
| filePath = originalFilePath + extension; |
| stats = undefined; |
| try { |
| stats = yield exports.stat(filePath); |
| } |
| catch (err) { |
| if (err.code !== 'ENOENT') { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); |
| } |
| } |
| if (stats && stats.isFile()) { |
| if (exports.IS_WINDOWS) { |
| // preserve the case of the actual file (since an extension was appended) |
| try { |
| const directory = path.dirname(filePath); |
| const upperName = path.basename(filePath).toUpperCase(); |
| for (const actualName of yield exports.readdir(directory)) { |
| if (upperName === actualName.toUpperCase()) { |
| filePath = path.join(directory, actualName); |
| break; |
| } |
| } |
| } |
| catch (err) { |
| // eslint-disable-next-line no-console |
| console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); |
| } |
| return filePath; |
| } |
| else { |
| if (isUnixExecutable(stats)) { |
| return filePath; |
| } |
| } |
| } |
| } |
| return ''; |
| }); |
| } |
| exports.tryGetExecutablePath = tryGetExecutablePath; |
| function normalizeSeparators(p) { |
| p = p || ''; |
| if (exports.IS_WINDOWS) { |
| // convert slashes on Windows |
| p = p.replace(/\//g, '\\'); |
| // remove redundant slashes |
| return p.replace(/\\\\+/g, '\\'); |
| } |
| // remove redundant slashes |
| return p.replace(/\/\/+/g, '/'); |
| } |
| // on Mac/Linux, test the execute bit |
| // R W X R W X R W X |
| // 256 128 64 32 16 8 4 2 1 |
| function isUnixExecutable(stats) { |
| return ((stats.mode & 1) > 0 || |
| ((stats.mode & 8) > 0 && stats.gid === process.getgid()) || |
| ((stats.mode & 64) > 0 && stats.uid === process.getuid())); |
| } |
| //# sourceMappingURL=io-util.js.map |
| |
| /***/ }), |
| |
| /***/ 7436: |
| /***/ (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 })); |
| const childProcess = __nccwpck_require__(3129); |
| const path = __nccwpck_require__(5622); |
| const util_1 = __nccwpck_require__(1669); |
| const ioUtil = __nccwpck_require__(1962); |
| const exec = util_1.promisify(childProcess.exec); |
| /** |
| * Copies a file or folder. |
| * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js |
| * |
| * @param source source path |
| * @param dest destination path |
| * @param options optional. See CopyOptions. |
| */ |
| function cp(source, dest, options = {}) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const { force, recursive } = readCopyOptions(options); |
| const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; |
| // Dest is an existing file, but not forcing |
| if (destStat && destStat.isFile() && !force) { |
| return; |
| } |
| // If dest is an existing directory, should copy inside. |
| const newDest = destStat && destStat.isDirectory() |
| ? path.join(dest, path.basename(source)) |
| : dest; |
| if (!(yield ioUtil.exists(source))) { |
| throw new Error(`no such file or directory: ${source}`); |
| } |
| const sourceStat = yield ioUtil.stat(source); |
| if (sourceStat.isDirectory()) { |
| if (!recursive) { |
| throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); |
| } |
| else { |
| yield cpDirRecursive(source, newDest, 0, force); |
| } |
| } |
| else { |
| if (path.relative(source, newDest) === '') { |
| // a file cannot be copied to itself |
| throw new Error(`'${newDest}' and '${source}' are the same file`); |
| } |
| yield copyFile(source, newDest, force); |
| } |
| }); |
| } |
| exports.cp = cp; |
| /** |
| * Moves a path. |
| * |
| * @param source source path |
| * @param dest destination path |
| * @param options optional. See MoveOptions. |
| */ |
| function mv(source, dest, options = {}) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (yield ioUtil.exists(dest)) { |
| let destExists = true; |
| if (yield ioUtil.isDirectory(dest)) { |
| // If dest is directory copy src into dest |
| dest = path.join(dest, path.basename(source)); |
| destExists = yield ioUtil.exists(dest); |
| } |
| if (destExists) { |
| if (options.force == null || options.force) { |
| yield rmRF(dest); |
| } |
| else { |
| throw new Error('Destination already exists'); |
| } |
| } |
| } |
| yield mkdirP(path.dirname(dest)); |
| yield ioUtil.rename(source, dest); |
| }); |
| } |
| exports.mv = mv; |
| /** |
| * Remove a path recursively with force |
| * |
| * @param inputPath path to remove |
| */ |
| function rmRF(inputPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (ioUtil.IS_WINDOWS) { |
| // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another |
| // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del. |
| try { |
| if (yield ioUtil.isDirectory(inputPath, true)) { |
| yield exec(`rd /s /q "${inputPath}"`); |
| } |
| else { |
| yield exec(`del /f /a "${inputPath}"`); |
| } |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| } |
| // Shelling out fails to remove a symlink folder with missing source, this unlink catches that |
| try { |
| yield ioUtil.unlink(inputPath); |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| } |
| } |
| else { |
| let isDir = false; |
| try { |
| isDir = yield ioUtil.isDirectory(inputPath); |
| } |
| catch (err) { |
| // if you try to delete a file that doesn't exist, desired result is achieved |
| // other errors are valid |
| if (err.code !== 'ENOENT') |
| throw err; |
| return; |
| } |
| if (isDir) { |
| yield exec(`rm -rf "${inputPath}"`); |
| } |
| else { |
| yield ioUtil.unlink(inputPath); |
| } |
| } |
| }); |
| } |
| exports.rmRF = rmRF; |
| /** |
| * Make a directory. Creates the full path with folders in between |
| * Will throw if it fails |
| * |
| * @param fsPath path to create |
| * @returns Promise<void> |
| */ |
| function mkdirP(fsPath) { |
| return __awaiter(this, void 0, void 0, function* () { |
| yield ioUtil.mkdirP(fsPath); |
| }); |
| } |
| exports.mkdirP = mkdirP; |
| /** |
| * Returns path of a tool had the tool actually been invoked. Resolves via paths. |
| * If you check and the tool does not exist, it will throw. |
| * |
| * @param tool name of the tool |
| * @param check whether to check if tool exists |
| * @returns Promise<string> path to tool |
| */ |
| function which(tool, check) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (!tool) { |
| throw new Error("parameter 'tool' is required"); |
| } |
| // recursive when check=true |
| if (check) { |
| const result = yield which(tool, false); |
| if (!result) { |
| if (ioUtil.IS_WINDOWS) { |
| throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); |
| } |
| else { |
| throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); |
| } |
| } |
| } |
| try { |
| // build the list of extensions to try |
| const extensions = []; |
| if (ioUtil.IS_WINDOWS && process.env.PATHEXT) { |
| for (const extension of process.env.PATHEXT.split(path.delimiter)) { |
| if (extension) { |
| extensions.push(extension); |
| } |
| } |
| } |
| // if it's rooted, return it if exists. otherwise return empty. |
| if (ioUtil.isRooted(tool)) { |
| const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); |
| if (filePath) { |
| return filePath; |
| } |
| return ''; |
| } |
| // if any path separators, return empty |
| if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) { |
| return ''; |
| } |
| // build the list of directories |
| // |
| // Note, technically "where" checks the current directory on Windows. From a toolkit perspective, |
| // it feels like we should not do this. Checking the current directory seems like more of a use |
| // case of a shell, and the which() function exposed by the toolkit should strive for consistency |
| // across platforms. |
| const directories = []; |
| if (process.env.PATH) { |
| for (const p of process.env.PATH.split(path.delimiter)) { |
| if (p) { |
| directories.push(p); |
| } |
| } |
| } |
| // return the first match |
| for (const directory of directories) { |
| const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions); |
| if (filePath) { |
| return filePath; |
| } |
| } |
| return ''; |
| } |
| catch (err) { |
| throw new Error(`which failed with message ${err.message}`); |
| } |
| }); |
| } |
| exports.which = which; |
| function readCopyOptions(options) { |
| const force = options.force == null ? true : options.force; |
| const recursive = Boolean(options.recursive); |
| return { force, recursive }; |
| } |
| function cpDirRecursive(sourceDir, destDir, currentDepth, force) { |
| return __awaiter(this, void 0, void 0, function* () { |
| // Ensure there is not a run away recursive copy |
| if (currentDepth >= 255) |
| return; |
| currentDepth++; |
| yield mkdirP(destDir); |
| const files = yield ioUtil.readdir(sourceDir); |
| for (const fileName of files) { |
| const srcFile = `${sourceDir}/${fileName}`; |
| const destFile = `${destDir}/${fileName}`; |
| const srcFileStat = yield ioUtil.lstat(srcFile); |
| if (srcFileStat.isDirectory()) { |
| // Recurse |
| yield cpDirRecursive(srcFile, destFile, currentDepth, force); |
| } |
| else { |
| yield copyFile(srcFile, destFile, force); |
| } |
| } |
| // Change the mode for the newly created directory |
| yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); |
| }); |
| } |
| // Buffered file copy |
| function copyFile(srcFile, destFile, force) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { |
| // unlink/re-link it |
| try { |
| yield ioUtil.lstat(destFile); |
| yield ioUtil.unlink(destFile); |
| } |
| catch (e) { |
| // Try to override file permission |
| if (e.code === 'EPERM') { |
| yield ioUtil.chmod(destFile, '0666'); |
| yield ioUtil.unlink(destFile); |
| } |
| // other errors = it doesn't exist, no work to do |
| } |
| // Copy over symlink |
| const symlinkFull = yield ioUtil.readlink(srcFile); |
| yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); |
| } |
| else if (!(yield ioUtil.exists(destFile)) || force) { |
| yield ioUtil.copyFile(srcFile, destFile); |
| } |
| }); |
| } |
| //# sourceMappingURL=io.js.map |
| |
| /***/ }), |
| |
| /***/ 3803: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0; |
| const fs = __nccwpck_require__(5747); |
| exports.FILE_SYSTEM_ADAPTER = { |
| lstat: fs.lstat, |
| stat: fs.stat, |
| lstatSync: fs.lstatSync, |
| statSync: fs.statSync, |
| readdir: fs.readdir, |
| readdirSync: fs.readdirSync |
| }; |
| function createFileSystemAdapter(fsMethods) { |
| if (fsMethods === undefined) { |
| return exports.FILE_SYSTEM_ADAPTER; |
| } |
| return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods); |
| } |
| exports.createFileSystemAdapter = createFileSystemAdapter; |
| |
| |
| /***/ }), |
| |
| /***/ 8838: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0; |
| const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.'); |
| const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10); |
| const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10); |
| const SUPPORTED_MAJOR_VERSION = 10; |
| const SUPPORTED_MINOR_VERSION = 10; |
| const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION; |
| const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION; |
| /** |
| * IS `true` for Node.js 10.10 and greater. |
| */ |
| exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR; |
| |
| |
| /***/ }), |
| |
| /***/ 5667: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.Settings = exports.scandirSync = exports.scandir = void 0; |
| const async = __nccwpck_require__(4507); |
| const sync = __nccwpck_require__(9560); |
| const settings_1 = __nccwpck_require__(8662); |
| exports.Settings = settings_1.default; |
| function scandir(path, optionsOrSettingsOrCallback, callback) { |
| if (typeof optionsOrSettingsOrCallback === 'function') { |
| return async.read(path, getSettings(), optionsOrSettingsOrCallback); |
| } |
| async.read(path, getSettings(optionsOrSettingsOrCallback), callback); |
| } |
| exports.scandir = scandir; |
| function scandirSync(path, optionsOrSettings) { |
| const settings = getSettings(optionsOrSettings); |
| return sync.read(path, settings); |
| } |
| exports.scandirSync = scandirSync; |
| function getSettings(settingsOrOptions = {}) { |
| if (settingsOrOptions instanceof settings_1.default) { |
| return settingsOrOptions; |
| } |
| return new settings_1.default(settingsOrOptions); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 4507: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.readdir = exports.readdirWithFileTypes = exports.read = void 0; |
| const fsStat = __nccwpck_require__(109); |
| const rpl = __nccwpck_require__(5288); |
| const constants_1 = __nccwpck_require__(8838); |
| const utils = __nccwpck_require__(6297); |
| const common = __nccwpck_require__(3847); |
| function read(directory, settings, callback) { |
| if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) { |
| return readdirWithFileTypes(directory, settings, callback); |
| } |
| return readdir(directory, settings, callback); |
| } |
| exports.read = read; |
| function readdirWithFileTypes(directory, settings, callback) { |
| settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => { |
| if (readdirError !== null) { |
| return callFailureCallback(callback, readdirError); |
| } |
| const entries = dirents.map((dirent) => ({ |
| dirent, |
| name: dirent.name, |
| path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator) |
| })); |
| if (!settings.followSymbolicLinks) { |
| return callSuccessCallback(callback, entries); |
| } |
| const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings)); |
| rpl(tasks, (rplError, rplEntries) => { |
| if (rplError !== null) { |
| return callFailureCallback(callback, rplError); |
| } |
| callSuccessCallback(callback, rplEntries); |
| }); |
| }); |
| } |
| exports.readdirWithFileTypes = readdirWithFileTypes; |
| function makeRplTaskEntry(entry, settings) { |
| return (done) => { |
| if (!entry.dirent.isSymbolicLink()) { |
| return done(null, entry); |
| } |
| settings.fs.stat(entry.path, (statError, stats) => { |
| if (statError !== null) { |
| if (settings.throwErrorOnBrokenSymbolicLink) { |
| return done(statError); |
| } |
| return done(null, entry); |
| } |
| entry.dirent = utils.fs.createDirentFromStats(entry.name, stats); |
| return done(null, entry); |
| }); |
| }; |
| } |
| function readdir(directory, settings, callback) { |
| settings.fs.readdir(directory, (readdirError, names) => { |
| if (readdirError !== null) { |
| return callFailureCallback(callback, readdirError); |
| } |
| const filepaths = names.map((name) => common.joinPathSegments(directory, name, settings.pathSegmentSeparator)); |
| const tasks = filepaths.map((filepath) => { |
| return (done) => fsStat.stat(filepath, settings.fsStatSettings, done); |
| }); |
| rpl(tasks, (rplError, results) => { |
| if (rplError !== null) { |
| return callFailureCallback(callback, rplError); |
| } |
| const entries = []; |
| names.forEach((name, index) => { |
| const stats = results[index]; |
| const entry = { |
| name, |
| path: filepaths[index], |
| dirent: utils.fs.createDirentFromStats(name, stats) |
| }; |
| if (settings.stats) { |
| entry.stats = stats; |
| } |
| entries.push(entry); |
| }); |
| callSuccessCallback(callback, entries); |
| }); |
| }); |
| } |
| exports.readdir = readdir; |
| function callFailureCallback(callback, error) { |
| callback(error); |
| } |
| function callSuccessCallback(callback, result) { |
| callback(null, result); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 3847: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.joinPathSegments = void 0; |
| function joinPathSegments(a, b, separator) { |
| /** |
| * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`). |
| */ |
| if (a.endsWith(separator)) { |
| return a + b; |
| } |
| return a + separator + b; |
| } |
| exports.joinPathSegments = joinPathSegments; |
| |
| |
| /***/ }), |
| |
| /***/ 9560: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.readdir = exports.readdirWithFileTypes = exports.read = void 0; |
| const fsStat = __nccwpck_require__(109); |
| const constants_1 = __nccwpck_require__(8838); |
| const utils = __nccwpck_require__(6297); |
| const common = __nccwpck_require__(3847); |
| function read(directory, settings) { |
| if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) { |
| return readdirWithFileTypes(directory, settings); |
| } |
| return readdir(directory, settings); |
| } |
| exports.read = read; |
| function readdirWithFileTypes(directory, settings) { |
| const dirents = settings.fs.readdirSync(directory, { withFileTypes: true }); |
| return dirents.map((dirent) => { |
| const entry = { |
| dirent, |
| name: dirent.name, |
| path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator) |
| }; |
| if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) { |
| try { |
| const stats = settings.fs.statSync(entry.path); |
| entry.dirent = utils.fs.createDirentFromStats(entry.name, stats); |
| } |
| catch (error) { |
| if (settings.throwErrorOnBrokenSymbolicLink) { |
| throw error; |
| } |
| } |
| } |
| return entry; |
| }); |
| } |
| exports.readdirWithFileTypes = readdirWithFileTypes; |
| function readdir(directory, settings) { |
| const names = settings.fs.readdirSync(directory); |
| return names.map((name) => { |
| const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator); |
| const stats = fsStat.statSync(entryPath, settings.fsStatSettings); |
| const entry = { |
| name, |
| path: entryPath, |
| dirent: utils.fs.createDirentFromStats(name, stats) |
| }; |
| if (settings.stats) { |
| entry.stats = stats; |
| } |
| return entry; |
| }); |
| } |
| exports.readdir = readdir; |
| |
| |
| /***/ }), |
| |
| /***/ 8662: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const path = __nccwpck_require__(5622); |
| const fsStat = __nccwpck_require__(109); |
| const fs = __nccwpck_require__(3803); |
| class Settings { |
| constructor(_options = {}) { |
| this._options = _options; |
| this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false); |
| this.fs = fs.createFileSystemAdapter(this._options.fs); |
| this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep); |
| this.stats = this._getValue(this._options.stats, false); |
| this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true); |
| this.fsStatSettings = new fsStat.Settings({ |
| followSymbolicLink: this.followSymbolicLinks, |
| fs: this.fs, |
| throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink |
| }); |
| } |
| _getValue(option, value) { |
| return option !== null && option !== void 0 ? option : value; |
| } |
| } |
| exports.default = Settings; |
| |
| |
| /***/ }), |
| |
| /***/ 883: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.createDirentFromStats = void 0; |
| class DirentFromStats { |
| constructor(name, stats) { |
| this.name = name; |
| this.isBlockDevice = stats.isBlockDevice.bind(stats); |
| this.isCharacterDevice = stats.isCharacterDevice.bind(stats); |
| this.isDirectory = stats.isDirectory.bind(stats); |
| this.isFIFO = stats.isFIFO.bind(stats); |
| this.isFile = stats.isFile.bind(stats); |
| this.isSocket = stats.isSocket.bind(stats); |
| this.isSymbolicLink = stats.isSymbolicLink.bind(stats); |
| } |
| } |
| function createDirentFromStats(name, stats) { |
| return new DirentFromStats(name, stats); |
| } |
| exports.createDirentFromStats = createDirentFromStats; |
| |
| |
| /***/ }), |
| |
| /***/ 6297: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.fs = void 0; |
| const fs = __nccwpck_require__(883); |
| exports.fs = fs; |
| |
| |
| /***/ }), |
| |
| /***/ 2987: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0; |
| const fs = __nccwpck_require__(5747); |
| exports.FILE_SYSTEM_ADAPTER = { |
| lstat: fs.lstat, |
| stat: fs.stat, |
| lstatSync: fs.lstatSync, |
| statSync: fs.statSync |
| }; |
| function createFileSystemAdapter(fsMethods) { |
| if (fsMethods === undefined) { |
| return exports.FILE_SYSTEM_ADAPTER; |
| } |
| return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods); |
| } |
| exports.createFileSystemAdapter = createFileSystemAdapter; |
| |
| |
| /***/ }), |
| |
| /***/ 109: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.statSync = exports.stat = exports.Settings = void 0; |
| const async = __nccwpck_require__(4147); |
| const sync = __nccwpck_require__(4527); |
| const settings_1 = __nccwpck_require__(2410); |
| exports.Settings = settings_1.default; |
| function stat(path, optionsOrSettingsOrCallback, callback) { |
| if (typeof optionsOrSettingsOrCallback === 'function') { |
| return async.read(path, getSettings(), optionsOrSettingsOrCallback); |
| } |
| async.read(path, getSettings(optionsOrSettingsOrCallback), callback); |
| } |
| exports.stat = stat; |
| function statSync(path, optionsOrSettings) { |
| const settings = getSettings(optionsOrSettings); |
| return sync.read(path, settings); |
| } |
| exports.statSync = statSync; |
| function getSettings(settingsOrOptions = {}) { |
| if (settingsOrOptions instanceof settings_1.default) { |
| return settingsOrOptions; |
| } |
| return new settings_1.default(settingsOrOptions); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 4147: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.read = void 0; |
| function read(path, settings, callback) { |
| settings.fs.lstat(path, (lstatError, lstat) => { |
| if (lstatError !== null) { |
| return callFailureCallback(callback, lstatError); |
| } |
| if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) { |
| return callSuccessCallback(callback, lstat); |
| } |
| settings.fs.stat(path, (statError, stat) => { |
| if (statError !== null) { |
| if (settings.throwErrorOnBrokenSymbolicLink) { |
| return callFailureCallback(callback, statError); |
| } |
| return callSuccessCallback(callback, lstat); |
| } |
| if (settings.markSymbolicLink) { |
| stat.isSymbolicLink = () => true; |
| } |
| callSuccessCallback(callback, stat); |
| }); |
| }); |
| } |
| exports.read = read; |
| function callFailureCallback(callback, error) { |
| callback(error); |
| } |
| function callSuccessCallback(callback, result) { |
| callback(null, result); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 4527: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.read = void 0; |
| function read(path, settings) { |
| const lstat = settings.fs.lstatSync(path); |
| if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) { |
| return lstat; |
| } |
| try { |
| const stat = settings.fs.statSync(path); |
| if (settings.markSymbolicLink) { |
| stat.isSymbolicLink = () => true; |
| } |
| return stat; |
| } |
| catch (error) { |
| if (!settings.throwErrorOnBrokenSymbolicLink) { |
| return lstat; |
| } |
| throw error; |
| } |
| } |
| exports.read = read; |
| |
| |
| /***/ }), |
| |
| /***/ 2410: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const fs = __nccwpck_require__(2987); |
| class Settings { |
| constructor(_options = {}) { |
| this._options = _options; |
| this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true); |
| this.fs = fs.createFileSystemAdapter(this._options.fs); |
| this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false); |
| this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true); |
| } |
| _getValue(option, value) { |
| return option !== null && option !== void 0 ? option : value; |
| } |
| } |
| exports.default = Settings; |
| |
| |
| /***/ }), |
| |
| /***/ 6026: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.Settings = exports.walkStream = exports.walkSync = exports.walk = void 0; |
| const async_1 = __nccwpck_require__(7523); |
| const stream_1 = __nccwpck_require__(6737); |
| const sync_1 = __nccwpck_require__(3068); |
| const settings_1 = __nccwpck_require__(141); |
| exports.Settings = settings_1.default; |
| function walk(directory, optionsOrSettingsOrCallback, callback) { |
| if (typeof optionsOrSettingsOrCallback === 'function') { |
| return new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback); |
| } |
| new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback); |
| } |
| exports.walk = walk; |
| function walkSync(directory, optionsOrSettings) { |
| const settings = getSettings(optionsOrSettings); |
| const provider = new sync_1.default(directory, settings); |
| return provider.read(); |
| } |
| exports.walkSync = walkSync; |
| function walkStream(directory, optionsOrSettings) { |
| const settings = getSettings(optionsOrSettings); |
| const provider = new stream_1.default(directory, settings); |
| return provider.read(); |
| } |
| exports.walkStream = walkStream; |
| function getSettings(settingsOrOptions = {}) { |
| if (settingsOrOptions instanceof settings_1.default) { |
| return settingsOrOptions; |
| } |
| return new settings_1.default(settingsOrOptions); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 7523: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const async_1 = __nccwpck_require__(5732); |
| class AsyncProvider { |
| constructor(_root, _settings) { |
| this._root = _root; |
| this._settings = _settings; |
| this._reader = new async_1.default(this._root, this._settings); |
| this._storage = new Set(); |
| } |
| read(callback) { |
| this._reader.onError((error) => { |
| callFailureCallback(callback, error); |
| }); |
| this._reader.onEntry((entry) => { |
| this._storage.add(entry); |
| }); |
| this._reader.onEnd(() => { |
| callSuccessCallback(callback, [...this._storage]); |
| }); |
| this._reader.read(); |
| } |
| } |
| exports.default = AsyncProvider; |
| function callFailureCallback(callback, error) { |
| callback(error); |
| } |
| function callSuccessCallback(callback, entries) { |
| callback(null, entries); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 6737: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const stream_1 = __nccwpck_require__(2413); |
| const async_1 = __nccwpck_require__(5732); |
| class StreamProvider { |
| constructor(_root, _settings) { |
| this._root = _root; |
| this._settings = _settings; |
| this._reader = new async_1.default(this._root, this._settings); |
| this._stream = new stream_1.Readable({ |
| objectMode: true, |
| read: () => { }, |
| destroy: () => { |
| if (!this._reader.isDestroyed) { |
| this._reader.destroy(); |
| } |
| } |
| }); |
| } |
| read() { |
| this._reader.onError((error) => { |
| this._stream.emit('error', error); |
| }); |
| this._reader.onEntry((entry) => { |
| this._stream.push(entry); |
| }); |
| this._reader.onEnd(() => { |
| this._stream.push(null); |
| }); |
| this._reader.read(); |
| return this._stream; |
| } |
| } |
| exports.default = StreamProvider; |
| |
| |
| /***/ }), |
| |
| /***/ 3068: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const sync_1 = __nccwpck_require__(3595); |
| class SyncProvider { |
| constructor(_root, _settings) { |
| this._root = _root; |
| this._settings = _settings; |
| this._reader = new sync_1.default(this._root, this._settings); |
| } |
| read() { |
| return this._reader.read(); |
| } |
| } |
| exports.default = SyncProvider; |
| |
| |
| /***/ }), |
| |
| /***/ 5732: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const events_1 = __nccwpck_require__(8614); |
| const fsScandir = __nccwpck_require__(5667); |
| const fastq = __nccwpck_require__(7340); |
| const common = __nccwpck_require__(7988); |
| const reader_1 = __nccwpck_require__(8311); |
| class AsyncReader extends reader_1.default { |
| constructor(_root, _settings) { |
| super(_root, _settings); |
| this._settings = _settings; |
| this._scandir = fsScandir.scandir; |
| this._emitter = new events_1.EventEmitter(); |
| this._queue = fastq(this._worker.bind(this), this._settings.concurrency); |
| this._isFatalError = false; |
| this._isDestroyed = false; |
| this._queue.drain = () => { |
| if (!this._isFatalError) { |
| this._emitter.emit('end'); |
| } |
| }; |
| } |
| read() { |
| this._isFatalError = false; |
| this._isDestroyed = false; |
| setImmediate(() => { |
| this._pushToQueue(this._root, this._settings.basePath); |
| }); |
| return this._emitter; |
| } |
| get isDestroyed() { |
| return this._isDestroyed; |
| } |
| destroy() { |
| if (this._isDestroyed) { |
| throw new Error('The reader is already destroyed'); |
| } |
| this._isDestroyed = true; |
| this._queue.killAndDrain(); |
| } |
| onEntry(callback) { |
| this._emitter.on('entry', callback); |
| } |
| onError(callback) { |
| this._emitter.once('error', callback); |
| } |
| onEnd(callback) { |
| this._emitter.once('end', callback); |
| } |
| _pushToQueue(directory, base) { |
| const queueItem = { directory, base }; |
| this._queue.push(queueItem, (error) => { |
| if (error !== null) { |
| this._handleError(error); |
| } |
| }); |
| } |
| _worker(item, done) { |
| this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => { |
| if (error !== null) { |
| return done(error, undefined); |
| } |
| for (const entry of entries) { |
| this._handleEntry(entry, item.base); |
| } |
| done(null, undefined); |
| }); |
| } |
| _handleError(error) { |
| if (this._isDestroyed || !common.isFatalError(this._settings, error)) { |
| return; |
| } |
| this._isFatalError = true; |
| this._isDestroyed = true; |
| this._emitter.emit('error', error); |
| } |
| _handleEntry(entry, base) { |
| if (this._isDestroyed || this._isFatalError) { |
| return; |
| } |
| const fullpath = entry.path; |
| if (base !== undefined) { |
| entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator); |
| } |
| if (common.isAppliedFilter(this._settings.entryFilter, entry)) { |
| this._emitEntry(entry); |
| } |
| if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) { |
| this._pushToQueue(fullpath, entry.path); |
| } |
| } |
| _emitEntry(entry) { |
| this._emitter.emit('entry', entry); |
| } |
| } |
| exports.default = AsyncReader; |
| |
| |
| /***/ }), |
| |
| /***/ 7988: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.joinPathSegments = exports.replacePathSegmentSeparator = exports.isAppliedFilter = exports.isFatalError = void 0; |
| function isFatalError(settings, error) { |
| if (settings.errorFilter === null) { |
| return true; |
| } |
| return !settings.errorFilter(error); |
| } |
| exports.isFatalError = isFatalError; |
| function isAppliedFilter(filter, value) { |
| return filter === null || filter(value); |
| } |
| exports.isAppliedFilter = isAppliedFilter; |
| function replacePathSegmentSeparator(filepath, separator) { |
| return filepath.split(/[/\\]/).join(separator); |
| } |
| exports.replacePathSegmentSeparator = replacePathSegmentSeparator; |
| function joinPathSegments(a, b, separator) { |
| if (a === '') { |
| return b; |
| } |
| /** |
| * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`). |
| */ |
| if (a.endsWith(separator)) { |
| return a + b; |
| } |
| return a + separator + b; |
| } |
| exports.joinPathSegments = joinPathSegments; |
| |
| |
| /***/ }), |
| |
| /***/ 8311: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const common = __nccwpck_require__(7988); |
| class Reader { |
| constructor(_root, _settings) { |
| this._root = _root; |
| this._settings = _settings; |
| this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator); |
| } |
| } |
| exports.default = Reader; |
| |
| |
| /***/ }), |
| |
| /***/ 3595: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const fsScandir = __nccwpck_require__(5667); |
| const common = __nccwpck_require__(7988); |
| const reader_1 = __nccwpck_require__(8311); |
| class SyncReader extends reader_1.default { |
| constructor() { |
| super(...arguments); |
| this._scandir = fsScandir.scandirSync; |
| this._storage = new Set(); |
| this._queue = new Set(); |
| } |
| read() { |
| this._pushToQueue(this._root, this._settings.basePath); |
| this._handleQueue(); |
| return [...this._storage]; |
| } |
| _pushToQueue(directory, base) { |
| this._queue.add({ directory, base }); |
| } |
| _handleQueue() { |
| for (const item of this._queue.values()) { |
| this._handleDirectory(item.directory, item.base); |
| } |
| } |
| _handleDirectory(directory, base) { |
| try { |
| const entries = this._scandir(directory, this._settings.fsScandirSettings); |
| for (const entry of entries) { |
| this._handleEntry(entry, base); |
| } |
| } |
| catch (error) { |
| this._handleError(error); |
| } |
| } |
| _handleError(error) { |
| if (!common.isFatalError(this._settings, error)) { |
| return; |
| } |
| throw error; |
| } |
| _handleEntry(entry, base) { |
| const fullpath = entry.path; |
| if (base !== undefined) { |
| entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator); |
| } |
| if (common.isAppliedFilter(this._settings.entryFilter, entry)) { |
| this._pushToStorage(entry); |
| } |
| if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) { |
| this._pushToQueue(fullpath, entry.path); |
| } |
| } |
| _pushToStorage(entry) { |
| this._storage.add(entry); |
| } |
| } |
| exports.default = SyncReader; |
| |
| |
| /***/ }), |
| |
| /***/ 141: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const path = __nccwpck_require__(5622); |
| const fsScandir = __nccwpck_require__(5667); |
| class Settings { |
| constructor(_options = {}) { |
| this._options = _options; |
| this.basePath = this._getValue(this._options.basePath, undefined); |
| this.concurrency = this._getValue(this._options.concurrency, Infinity); |
| this.deepFilter = this._getValue(this._options.deepFilter, null); |
| this.entryFilter = this._getValue(this._options.entryFilter, null); |
| this.errorFilter = this._getValue(this._options.errorFilter, null); |
| this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep); |
| this.fsScandirSettings = new fsScandir.Settings({ |
| followSymbolicLinks: this._options.followSymbolicLinks, |
| fs: this._options.fs, |
| pathSegmentSeparator: this._options.pathSegmentSeparator, |
| stats: this._options.stats, |
| throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink |
| }); |
| } |
| _getValue(option, value) { |
| return option !== null && option !== void 0 ? option : value; |
| } |
| } |
| exports.default = Settings; |
| |
| |
| /***/ }), |
| |
| /***/ 334: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| async function auth(token) { |
| const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth"; |
| return { |
| type: "token", |
| token: token, |
| tokenType |
| }; |
| } |
| |
| /** |
| * Prefix token for usage in the Authorization header |
| * |
| * @param token OAuth token or JSON Web Token |
| */ |
| function withAuthorizationPrefix(token) { |
| if (token.split(/\./).length === 3) { |
| return `bearer ${token}`; |
| } |
| |
| return `token ${token}`; |
| } |
| |
| async function hook(token, request, route, parameters) { |
| const endpoint = request.endpoint.merge(route, parameters); |
| endpoint.headers.authorization = withAuthorizationPrefix(token); |
| return request(endpoint); |
| } |
| |
| const createTokenAuth = function createTokenAuth(token) { |
| if (!token) { |
| throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); |
| } |
| |
| if (typeof token !== "string") { |
| throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); |
| } |
| |
| token = token.replace(/^(token|bearer) +/i, ""); |
| return Object.assign(auth.bind(null, token), { |
| hook: hook.bind(null, token) |
| }); |
| }; |
| |
| exports.createTokenAuth = createTokenAuth; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 6762: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| var universalUserAgent = __nccwpck_require__(5030); |
| var beforeAfterHook = __nccwpck_require__(3682); |
| var request = __nccwpck_require__(6234); |
| var graphql = __nccwpck_require__(8467); |
| var authToken = __nccwpck_require__(334); |
| |
| function _objectWithoutPropertiesLoose(source, excluded) { |
| if (source == null) return {}; |
| var target = {}; |
| var sourceKeys = Object.keys(source); |
| var key, i; |
| |
| for (i = 0; i < sourceKeys.length; i++) { |
| key = sourceKeys[i]; |
| if (excluded.indexOf(key) >= 0) continue; |
| target[key] = source[key]; |
| } |
| |
| return target; |
| } |
| |
| function _objectWithoutProperties(source, excluded) { |
| if (source == null) return {}; |
| |
| var target = _objectWithoutPropertiesLoose(source, excluded); |
| |
| var key, i; |
| |
| if (Object.getOwnPropertySymbols) { |
| var sourceSymbolKeys = Object.getOwnPropertySymbols(source); |
| |
| for (i = 0; i < sourceSymbolKeys.length; i++) { |
| key = sourceSymbolKeys[i]; |
| if (excluded.indexOf(key) >= 0) continue; |
| if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; |
| target[key] = source[key]; |
| } |
| } |
| |
| return target; |
| } |
| |
| const VERSION = "3.2.1"; |
| |
| class Octokit { |
| constructor(options = {}) { |
| const hook = new beforeAfterHook.Collection(); |
| const requestDefaults = { |
| baseUrl: request.request.endpoint.DEFAULTS.baseUrl, |
| headers: {}, |
| request: Object.assign({}, options.request, { |
| hook: hook.bind(null, "request") |
| }), |
| mediaType: { |
| previews: [], |
| format: "" |
| } |
| }; // prepend default user agent with `options.userAgent` if set |
| |
| requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" "); |
| |
| if (options.baseUrl) { |
| requestDefaults.baseUrl = options.baseUrl; |
| } |
| |
| if (options.previews) { |
| requestDefaults.mediaType.previews = options.previews; |
| } |
| |
| if (options.timeZone) { |
| requestDefaults.headers["time-zone"] = options.timeZone; |
| } |
| |
| this.request = request.request.defaults(requestDefaults); |
| this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults); |
| this.log = Object.assign({ |
| debug: () => {}, |
| info: () => {}, |
| warn: console.warn.bind(console), |
| error: console.error.bind(console) |
| }, options.log); |
| this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance |
| // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered. |
| // (2) If only `options.auth` is set, use the default token authentication strategy. |
| // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance. |
| // TODO: type `options.auth` based on `options.authStrategy`. |
| |
| if (!options.authStrategy) { |
| if (!options.auth) { |
| // (1) |
| this.auth = async () => ({ |
| type: "unauthenticated" |
| }); |
| } else { |
| // (2) |
| const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ¯\_(ツ)_/¯ |
| |
| hook.wrap("request", auth.hook); |
| this.auth = auth; |
| } |
| } else { |
| const { |
| authStrategy |
| } = options, |
| otherOptions = _objectWithoutProperties(options, ["authStrategy"]); |
| |
| const auth = authStrategy(Object.assign({ |
| request: this.request, |
| log: this.log, |
| // we pass the current octokit instance as well as its constructor options |
| // to allow for authentication strategies that return a new octokit instance |
| // that shares the same internal state as the current one. The original |
| // requirement for this was the "event-octokit" authentication strategy |
| // of https://github.com/probot/octokit-auth-probot. |
| octokit: this, |
| octokitOptions: otherOptions |
| }, options.auth)); // @ts-ignore ¯\_(ツ)_/¯ |
| |
| hook.wrap("request", auth.hook); |
| this.auth = auth; |
| } // apply plugins |
| // https://stackoverflow.com/a/16345172 |
| |
| |
| const classConstructor = this.constructor; |
| classConstructor.plugins.forEach(plugin => { |
| Object.assign(this, plugin(this, options)); |
| }); |
| } |
| |
| static defaults(defaults) { |
| const OctokitWithDefaults = class extends this { |
| constructor(...args) { |
| const options = args[0] || {}; |
| |
| if (typeof defaults === "function") { |
| super(defaults(options)); |
| return; |
| } |
| |
| super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { |
| userAgent: `${options.userAgent} ${defaults.userAgent}` |
| } : null)); |
| } |
| |
| }; |
| return OctokitWithDefaults; |
| } |
| /** |
| * Attach a plugin (or many) to your Octokit instance. |
| * |
| * @example |
| * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) |
| */ |
| |
| |
| static plugin(...newPlugins) { |
| var _a; |
| |
| const currentPlugins = this.plugins; |
| const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a); |
| return NewOctokit; |
| } |
| |
| } |
| Octokit.VERSION = VERSION; |
| Octokit.plugins = []; |
| |
| exports.Octokit = Octokit; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 9440: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| var isPlainObject = __nccwpck_require__(558); |
| var universalUserAgent = __nccwpck_require__(5030); |
| |
| function lowercaseKeys(object) { |
| if (!object) { |
| return {}; |
| } |
| |
| return Object.keys(object).reduce((newObj, key) => { |
| newObj[key.toLowerCase()] = object[key]; |
| return newObj; |
| }, {}); |
| } |
| |
| function mergeDeep(defaults, options) { |
| const result = Object.assign({}, defaults); |
| Object.keys(options).forEach(key => { |
| if (isPlainObject.isPlainObject(options[key])) { |
| if (!(key in defaults)) Object.assign(result, { |
| [key]: options[key] |
| });else result[key] = mergeDeep(defaults[key], options[key]); |
| } else { |
| Object.assign(result, { |
| [key]: options[key] |
| }); |
| } |
| }); |
| return result; |
| } |
| |
| function removeUndefinedProperties(obj) { |
| for (const key in obj) { |
| if (obj[key] === undefined) { |
| delete obj[key]; |
| } |
| } |
| |
| return obj; |
| } |
| |
| function merge(defaults, route, options) { |
| if (typeof route === "string") { |
| let [method, url] = route.split(" "); |
| options = Object.assign(url ? { |
| method, |
| url |
| } : { |
| url: method |
| }, options); |
| } else { |
| options = Object.assign({}, route); |
| } // lowercase header names before merging with defaults to avoid duplicates |
| |
| |
| options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging |
| |
| removeUndefinedProperties(options); |
| removeUndefinedProperties(options.headers); |
| const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten |
| |
| if (defaults && defaults.mediaType.previews.length) { |
| mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); |
| } |
| |
| mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, "")); |
| return mergedOptions; |
| } |
| |
| function addQueryParameters(url, parameters) { |
| const separator = /\?/.test(url) ? "&" : "?"; |
| const names = Object.keys(parameters); |
| |
| if (names.length === 0) { |
| return url; |
| } |
| |
| return url + separator + names.map(name => { |
| if (name === "q") { |
| return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); |
| } |
| |
| return `${name}=${encodeURIComponent(parameters[name])}`; |
| }).join("&"); |
| } |
| |
| const urlVariableRegex = /\{[^}]+\}/g; |
| |
| function removeNonChars(variableName) { |
| return variableName.replace(/^\W+|\W+$/g, "").split(/,/); |
| } |
| |
| function extractUrlVariableNames(url) { |
| const matches = url.match(urlVariableRegex); |
| |
| if (!matches) { |
| return []; |
| } |
| |
| return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); |
| } |
| |
| function omit(object, keysToOmit) { |
| return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => { |
| obj[key] = object[key]; |
| return obj; |
| }, {}); |
| } |
| |
| // Based on https://github.com/bramstein/url-template, licensed under BSD |
| // TODO: create separate package. |
| // |
| // Copyright (c) 2012-2014, Bram Stein |
| // All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // 1. Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the distribution. |
| // 3. The name of the author may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED |
| // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| // EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |
| // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| // OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| /* istanbul ignore file */ |
| function encodeReserved(str) { |
| return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { |
| if (!/%[0-9A-Fa-f]/.test(part)) { |
| part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); |
| } |
| |
| return part; |
| }).join(""); |
| } |
| |
| function encodeUnreserved(str) { |
| return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { |
| return "%" + c.charCodeAt(0).toString(16).toUpperCase(); |
| }); |
| } |
| |
| function encodeValue(operator, value, key) { |
| value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); |
| |
| if (key) { |
| return encodeUnreserved(key) + "=" + value; |
| } else { |
| return value; |
| } |
| } |
| |
| function isDefined(value) { |
| return value !== undefined && value !== null; |
| } |
| |
| function isKeyOperator(operator) { |
| return operator === ";" || operator === "&" || operator === "?"; |
| } |
| |
| function getValues(context, operator, key, modifier) { |
| var value = context[key], |
| result = []; |
| |
| if (isDefined(value) && value !== "") { |
| if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { |
| value = value.toString(); |
| |
| if (modifier && modifier !== "*") { |
| value = value.substring(0, parseInt(modifier, 10)); |
| } |
| |
| result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); |
| } else { |
| if (modifier === "*") { |
| if (Array.isArray(value)) { |
| value.filter(isDefined).forEach(function (value) { |
| result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); |
| }); |
| } else { |
| Object.keys(value).forEach(function (k) { |
| if (isDefined(value[k])) { |
| result.push(encodeValue(operator, value[k], k)); |
| } |
| }); |
| } |
| } else { |
| const tmp = []; |
| |
| if (Array.isArray(value)) { |
| value.filter(isDefined).forEach(function (value) { |
| tmp.push(encodeValue(operator, value)); |
| }); |
| } else { |
| Object.keys(value).forEach(function (k) { |
| if (isDefined(value[k])) { |
| tmp.push(encodeUnreserved(k)); |
| tmp.push(encodeValue(operator, value[k].toString())); |
| } |
| }); |
| } |
| |
| if (isKeyOperator(operator)) { |
| result.push(encodeUnreserved(key) + "=" + tmp.join(",")); |
| } else if (tmp.length !== 0) { |
| result.push(tmp.join(",")); |
| } |
| } |
| } |
| } else { |
| if (operator === ";") { |
| if (isDefined(value)) { |
| result.push(encodeUnreserved(key)); |
| } |
| } else if (value === "" && (operator === "&" || operator === "?")) { |
| result.push(encodeUnreserved(key) + "="); |
| } else if (value === "") { |
| result.push(""); |
| } |
| } |
| |
| return result; |
| } |
| |
| function parseUrl(template) { |
| return { |
| expand: expand.bind(null, template) |
| }; |
| } |
| |
| function expand(template, context) { |
| var operators = ["+", "#", ".", "/", ";", "?", "&"]; |
| return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { |
| if (expression) { |
| let operator = ""; |
| const values = []; |
| |
| if (operators.indexOf(expression.charAt(0)) !== -1) { |
| operator = expression.charAt(0); |
| expression = expression.substr(1); |
| } |
| |
| expression.split(/,/g).forEach(function (variable) { |
| var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); |
| values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); |
| }); |
| |
| if (operator && operator !== "+") { |
| var separator = ","; |
| |
| if (operator === "?") { |
| separator = "&"; |
| } else if (operator !== "#") { |
| separator = operator; |
| } |
| |
| return (values.length !== 0 ? operator : "") + values.join(separator); |
| } else { |
| return values.join(","); |
| } |
| } else { |
| return encodeReserved(literal); |
| } |
| }); |
| } |
| |
| function parse(options) { |
| // https://fetch.spec.whatwg.org/#methods |
| let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible |
| |
| let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); |
| let headers = Object.assign({}, options.headers); |
| let body; |
| let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later |
| |
| const urlVariableNames = extractUrlVariableNames(url); |
| url = parseUrl(url).expand(parameters); |
| |
| if (!/^http/.test(url)) { |
| url = options.baseUrl + url; |
| } |
| |
| const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl"); |
| const remainingParameters = omit(parameters, omittedParameters); |
| const isBinaryRequest = /application\/octet-stream/i.test(headers.accept); |
| |
| if (!isBinaryRequest) { |
| if (options.mediaType.format) { |
| // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw |
| headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); |
| } |
| |
| if (options.mediaType.previews.length) { |
| const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; |
| headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => { |
| const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; |
| return `application/vnd.github.${preview}-preview${format}`; |
| }).join(","); |
| } |
| } // for GET/HEAD requests, set URL query parameters from remaining parameters |
| // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters |
| |
| |
| if (["GET", "HEAD"].includes(method)) { |
| url = addQueryParameters(url, remainingParameters); |
| } else { |
| if ("data" in remainingParameters) { |
| body = remainingParameters.data; |
| } else { |
| if (Object.keys(remainingParameters).length) { |
| body = remainingParameters; |
| } else { |
| headers["content-length"] = 0; |
| } |
| } |
| } // default content-type for JSON if body is set |
| |
| |
| if (!headers["content-type"] && typeof body !== "undefined") { |
| headers["content-type"] = "application/json; charset=utf-8"; |
| } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body. |
| // fetch does not allow to set `content-length` header, but we can set body to an empty string |
| |
| |
| if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { |
| body = ""; |
| } // Only return body/request keys if present |
| |
| |
| return Object.assign({ |
| method, |
| url, |
| headers |
| }, typeof body !== "undefined" ? { |
| body |
| } : null, options.request ? { |
| request: options.request |
| } : null); |
| } |
| |
| function endpointWithDefaults(defaults, route, options) { |
| return parse(merge(defaults, route, options)); |
| } |
| |
| function withDefaults(oldDefaults, newDefaults) { |
| const DEFAULTS = merge(oldDefaults, newDefaults); |
| const endpoint = endpointWithDefaults.bind(null, DEFAULTS); |
| return Object.assign(endpoint, { |
| DEFAULTS, |
| defaults: withDefaults.bind(null, DEFAULTS), |
| merge: merge.bind(null, DEFAULTS), |
| parse |
| }); |
| } |
| |
| const VERSION = "6.0.9"; |
| |
| const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url. |
| // So we use RequestParameters and add method as additional required property. |
| |
| const DEFAULTS = { |
| method: "GET", |
| baseUrl: "https://api.github.com", |
| headers: { |
| accept: "application/vnd.github.v3+json", |
| "user-agent": userAgent |
| }, |
| mediaType: { |
| format: "", |
| previews: [] |
| } |
| }; |
| |
| const endpoint = withDefaults(null, DEFAULTS); |
| |
| exports.endpoint = endpoint; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 558: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| /*! |
| * is-plain-object <https://github.com/jonschlinkert/is-plain-object> |
| * |
| * Copyright (c) 2014-2017, Jon Schlinkert. |
| * Released under the MIT License. |
| */ |
| |
| function isObject(o) { |
| return Object.prototype.toString.call(o) === '[object Object]'; |
| } |
| |
| function isPlainObject(o) { |
| var ctor,prot; |
| |
| if (isObject(o) === false) return false; |
| |
| // If has modified constructor |
| ctor = o.constructor; |
| if (ctor === undefined) return true; |
| |
| // If has modified prototype |
| prot = ctor.prototype; |
| if (isObject(prot) === false) return false; |
| |
| // If constructor does not have an Object-specific method |
| if (prot.hasOwnProperty('isPrototypeOf') === false) { |
| return false; |
| } |
| |
| // Most likely a plain Object |
| return true; |
| } |
| |
| exports.isPlainObject = isPlainObject; |
| |
| |
| /***/ }), |
| |
| /***/ 8467: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| var request = __nccwpck_require__(6234); |
| var universalUserAgent = __nccwpck_require__(5030); |
| |
| const VERSION = "4.5.7"; |
| |
| class GraphqlError extends Error { |
| constructor(request, response) { |
| const message = response.data.errors[0].message; |
| super(message); |
| Object.assign(this, response.data); |
| Object.assign(this, { |
| headers: response.headers |
| }); |
| this.name = "GraphqlError"; |
| this.request = request; // Maintains proper stack trace (only available on V8) |
| |
| /* istanbul ignore next */ |
| |
| if (Error.captureStackTrace) { |
| Error.captureStackTrace(this, this.constructor); |
| } |
| } |
| |
| } |
| |
| const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"]; |
| const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; |
| function graphql(request, query, options) { |
| if (typeof query === "string" && options && "query" in options) { |
| return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); |
| } |
| |
| const parsedOptions = typeof query === "string" ? Object.assign({ |
| query |
| }, options) : query; |
| const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { |
| if (NON_VARIABLE_OPTIONS.includes(key)) { |
| result[key] = parsedOptions[key]; |
| return result; |
| } |
| |
| if (!result.variables) { |
| result.variables = {}; |
| } |
| |
| result.variables[key] = parsedOptions[key]; |
| return result; |
| }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix |
| // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451 |
| |
| const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl; |
| |
| if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { |
| requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); |
| } |
| |
| return request(requestOptions).then(response => { |
| if (response.data.errors) { |
| const headers = {}; |
| |
| for (const key of Object.keys(response.headers)) { |
| headers[key] = response.headers[key]; |
| } |
| |
| throw new GraphqlError(requestOptions, { |
| headers, |
| data: response.data |
| }); |
| } |
| |
| return response.data.data; |
| }); |
| } |
| |
| function withDefaults(request$1, newDefaults) { |
| const newRequest = request$1.defaults(newDefaults); |
| |
| const newApi = (query, options) => { |
| return graphql(newRequest, query, options); |
| }; |
| |
| return Object.assign(newApi, { |
| defaults: withDefaults.bind(null, newRequest), |
| endpoint: request.request.endpoint |
| }); |
| } |
| |
| const graphql$1 = withDefaults(request.request, { |
| headers: { |
| "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}` |
| }, |
| method: "POST", |
| url: "/graphql" |
| }); |
| function withCustomRequest(customRequest) { |
| return withDefaults(customRequest, { |
| method: "POST", |
| url: "/graphql" |
| }); |
| } |
| |
| exports.graphql = graphql$1; |
| exports.withCustomRequest = withCustomRequest; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 4193: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| const VERSION = "2.6.0"; |
| |
| /** |
| * Some “list” response that can be paginated have a different response structure |
| * |
| * They have a `total_count` key in the response (search also has `incomplete_results`, |
| * /installation/repositories also has `repository_selection`), as well as a key with |
| * the list of the items which name varies from endpoint to endpoint. |
| * |
| * Octokit normalizes these responses so that paginated results are always returned following |
| * the same structure. One challenge is that if the list response has only one page, no Link |
| * header is provided, so this header alone is not sufficient to check wether a response is |
| * paginated or not. |
| * |
| * We check if a "total_count" key is present in the response data, but also make sure that |
| * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would |
| * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref |
| */ |
| function normalizePaginatedListResponse(response) { |
| const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); |
| if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way |
| // to retrieve the same information. |
| |
| const incompleteResults = response.data.incomplete_results; |
| const repositorySelection = response.data.repository_selection; |
| const totalCount = response.data.total_count; |
| delete response.data.incomplete_results; |
| delete response.data.repository_selection; |
| delete response.data.total_count; |
| const namespaceKey = Object.keys(response.data)[0]; |
| const data = response.data[namespaceKey]; |
| response.data = data; |
| |
| if (typeof incompleteResults !== "undefined") { |
| response.data.incomplete_results = incompleteResults; |
| } |
| |
| if (typeof repositorySelection !== "undefined") { |
| response.data.repository_selection = repositorySelection; |
| } |
| |
| response.data.total_count = totalCount; |
| return response; |
| } |
| |
| function iterator(octokit, route, parameters) { |
| const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); |
| const requestMethod = typeof route === "function" ? route : octokit.request; |
| const method = options.method; |
| const headers = options.headers; |
| let url = options.url; |
| return { |
| [Symbol.asyncIterator]: () => ({ |
| async next() { |
| if (!url) return { |
| done: true |
| }; |
| const response = await requestMethod({ |
| method, |
| url, |
| headers |
| }); |
| const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format: |
| // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"' |
| // sets `url` to undefined if "next" URL is not present or `link` header is not set |
| |
| url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1]; |
| return { |
| value: normalizedResponse |
| }; |
| } |
| |
| }) |
| }; |
| } |
| |
| function paginate(octokit, route, parameters, mapFn) { |
| if (typeof parameters === "function") { |
| mapFn = parameters; |
| parameters = undefined; |
| } |
| |
| return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); |
| } |
| |
| function gather(octokit, results, iterator, mapFn) { |
| return iterator.next().then(result => { |
| if (result.done) { |
| return results; |
| } |
| |
| let earlyExit = false; |
| |
| function done() { |
| earlyExit = true; |
| } |
| |
| results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); |
| |
| if (earlyExit) { |
| return results; |
| } |
| |
| return gather(octokit, results, iterator, mapFn); |
| }); |
| } |
| |
| const composePaginateRest = Object.assign(paginate, { |
| iterator |
| }); |
| |
| /** |
| * @param octokit Octokit instance |
| * @param options Options passed to Octokit constructor |
| */ |
| |
| function paginateRest(octokit) { |
| return { |
| paginate: Object.assign(paginate.bind(null, octokit), { |
| iterator: iterator.bind(null, octokit) |
| }) |
| }; |
| } |
| paginateRest.VERSION = VERSION; |
| |
| exports.composePaginateRest = composePaginateRest; |
| exports.paginateRest = paginateRest; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 3044: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| const Endpoints = { |
| actions: { |
| addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], |
| cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"], |
| createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], |
| createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"], |
| createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"], |
| createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"], |
| createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], |
| createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"], |
| createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"], |
| deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], |
| deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], |
| deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"], |
| deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"], |
| deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"], |
| deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], |
| deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], |
| downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"], |
| downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"], |
| downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], |
| getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], |
| getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], |
| getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], |
| getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], |
| getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], |
| getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], |
| getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], |
| getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"], |
| getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], |
| getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], |
| getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], |
| getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], |
| listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], |
| listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], |
| listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], |
| listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], |
| listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"], |
| listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"], |
| listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"], |
| listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"], |
| listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], |
| listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], |
| listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"], |
| listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"], |
| listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], |
| reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], |
| removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], |
| setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"] |
| }, |
| activity: { |
| checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"], |
| deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"], |
| deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"], |
| getFeeds: ["GET /feeds"], |
| getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"], |
| getThread: ["GET /notifications/threads/{thread_id}"], |
| getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"], |
| listEventsForAuthenticatedUser: ["GET /users/{username}/events"], |
| listNotificationsForAuthenticatedUser: ["GET /notifications"], |
| listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"], |
| listPublicEvents: ["GET /events"], |
| listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"], |
| listPublicEventsForUser: ["GET /users/{username}/events/public"], |
| listPublicOrgEvents: ["GET /orgs/{org}/events"], |
| listReceivedEventsForUser: ["GET /users/{username}/received_events"], |
| listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"], |
| listRepoEvents: ["GET /repos/{owner}/{repo}/events"], |
| listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"], |
| listReposStarredByAuthenticatedUser: ["GET /user/starred"], |
| listReposStarredByUser: ["GET /users/{username}/starred"], |
| listReposWatchedByUser: ["GET /users/{username}/subscriptions"], |
| listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"], |
| listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"], |
| listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"], |
| markNotificationsAsRead: ["PUT /notifications"], |
| markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"], |
| markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], |
| setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], |
| setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"], |
| starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], |
| unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] |
| }, |
| apps: { |
| addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"], |
| checkToken: ["POST /applications/{client_id}/token"], |
| createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", { |
| mediaType: { |
| previews: ["corsair"] |
| } |
| }], |
| createFromManifest: ["POST /app-manifests/{code}/conversions"], |
| createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"], |
| deleteAuthorization: ["DELETE /applications/{client_id}/grant"], |
| deleteInstallation: ["DELETE /app/installations/{installation_id}"], |
| deleteToken: ["DELETE /applications/{client_id}/token"], |
| getAuthenticated: ["GET /app"], |
| getBySlug: ["GET /apps/{app_slug}"], |
| getInstallation: ["GET /app/installations/{installation_id}"], |
| getOrgInstallation: ["GET /orgs/{org}/installation"], |
| getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], |
| getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"], |
| getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"], |
| getUserInstallation: ["GET /users/{username}/installation"], |
| listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], |
| listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"], |
| listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"], |
| listInstallations: ["GET /app/installations"], |
| listInstallationsForAuthenticatedUser: ["GET /user/installations"], |
| listPlans: ["GET /marketplace_listing/plans"], |
| listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], |
| listReposAccessibleToInstallation: ["GET /installation/repositories"], |
| listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], |
| listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"], |
| removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"], |
| resetToken: ["PATCH /applications/{client_id}/token"], |
| revokeInstallationAccessToken: ["DELETE /installation/token"], |
| suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], |
| unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"] |
| }, |
| billing: { |
| getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], |
| getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"], |
| getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], |
| getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"], |
| getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"], |
| getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"] |
| }, |
| checks: { |
| create: ["POST /repos/{owner}/{repo}/check-runs", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| createSuite: ["POST /repos/{owner}/{repo}/check-suites", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }], |
| update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}", { |
| mediaType: { |
| previews: ["antiope"] |
| } |
| }] |
| }, |
| codeScanning: { |
| getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, { |
| renamedParameters: { |
| alert_id: "alert_number" |
| } |
| }], |
| listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], |
| listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], |
| updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"], |
| uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] |
| }, |
| codesOfConduct: { |
| getAllCodesOfConduct: ["GET /codes_of_conduct", { |
| mediaType: { |
| previews: ["scarlet-witch"] |
| } |
| }], |
| getConductCode: ["GET /codes_of_conduct/{key}", { |
| mediaType: { |
| previews: ["scarlet-witch"] |
| } |
| }], |
| getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", { |
| mediaType: { |
| previews: ["scarlet-witch"] |
| } |
| }] |
| }, |
| emojis: { |
| get: ["GET /emojis"] |
| }, |
| gists: { |
| checkIsStarred: ["GET /gists/{gist_id}/star"], |
| create: ["POST /gists"], |
| createComment: ["POST /gists/{gist_id}/comments"], |
| delete: ["DELETE /gists/{gist_id}"], |
| deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], |
| fork: ["POST /gists/{gist_id}/forks"], |
| get: ["GET /gists/{gist_id}"], |
| getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], |
| getRevision: ["GET /gists/{gist_id}/{sha}"], |
| list: ["GET /gists"], |
| listComments: ["GET /gists/{gist_id}/comments"], |
| listCommits: ["GET /gists/{gist_id}/commits"], |
| listForUser: ["GET /users/{username}/gists"], |
| listForks: ["GET /gists/{gist_id}/forks"], |
| listPublic: ["GET /gists/public"], |
| listStarred: ["GET /gists/starred"], |
| star: ["PUT /gists/{gist_id}/star"], |
| unstar: ["DELETE /gists/{gist_id}/star"], |
| update: ["PATCH /gists/{gist_id}"], |
| updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] |
| }, |
| git: { |
| createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], |
| createCommit: ["POST /repos/{owner}/{repo}/git/commits"], |
| createRef: ["POST /repos/{owner}/{repo}/git/refs"], |
| createTag: ["POST /repos/{owner}/{repo}/git/tags"], |
| createTree: ["POST /repos/{owner}/{repo}/git/trees"], |
| deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], |
| getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], |
| getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], |
| getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], |
| getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], |
| getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], |
| listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], |
| updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] |
| }, |
| gitignore: { |
| getAllTemplates: ["GET /gitignore/templates"], |
| getTemplate: ["GET /gitignore/templates/{name}"] |
| }, |
| interactions: { |
| getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }], |
| getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }], |
| removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }], |
| removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }], |
| setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }], |
| setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits", { |
| mediaType: { |
| previews: ["sombra"] |
| } |
| }] |
| }, |
| issues: { |
| addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"], |
| addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], |
| checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], |
| create: ["POST /repos/{owner}/{repo}/issues"], |
| createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"], |
| createLabel: ["POST /repos/{owner}/{repo}/labels"], |
| createMilestone: ["POST /repos/{owner}/{repo}/milestones"], |
| deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"], |
| deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], |
| deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"], |
| get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], |
| getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], |
| getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], |
| getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], |
| getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], |
| list: ["GET /issues"], |
| listAssignees: ["GET /repos/{owner}/{repo}/assignees"], |
| listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], |
| listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], |
| listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], |
| listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], |
| listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", { |
| mediaType: { |
| previews: ["mockingbird"] |
| } |
| }], |
| listForAuthenticatedUser: ["GET /user/issues"], |
| listForOrg: ["GET /orgs/{org}/issues"], |
| listForRepo: ["GET /repos/{owner}/{repo}/issues"], |
| listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], |
| listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], |
| listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], |
| listMilestones: ["GET /repos/{owner}/{repo}/milestones"], |
| lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], |
| removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"], |
| removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"], |
| removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"], |
| setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], |
| unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], |
| update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], |
| updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], |
| updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], |
| updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"] |
| }, |
| licenses: { |
| get: ["GET /licenses/{license}"], |
| getAllCommonlyUsed: ["GET /licenses"], |
| getForRepo: ["GET /repos/{owner}/{repo}/license"] |
| }, |
| markdown: { |
| render: ["POST /markdown"], |
| renderRaw: ["POST /markdown/raw", { |
| headers: { |
| "content-type": "text/plain; charset=utf-8" |
| } |
| }] |
| }, |
| meta: { |
| get: ["GET /meta"] |
| }, |
| migrations: { |
| cancelImport: ["DELETE /repos/{owner}/{repo}/import"], |
| deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"], |
| getImportStatus: ["GET /repos/{owner}/{repo}/import"], |
| getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"], |
| getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| listForAuthenticatedUser: ["GET /user/migrations", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| listForOrg: ["GET /orgs/{org}/migrations", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| listReposForUser: ["GET /user/migrations/{migration_id}/repositories", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"], |
| setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"], |
| startForAuthenticatedUser: ["POST /user/migrations"], |
| startForOrg: ["POST /orgs/{org}/migrations"], |
| startImport: ["PUT /repos/{owner}/{repo}/import"], |
| unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", { |
| mediaType: { |
| previews: ["wyandotte"] |
| } |
| }], |
| updateImport: ["PATCH /repos/{owner}/{repo}/import"] |
| }, |
| orgs: { |
| blockUser: ["PUT /orgs/{org}/blocks/{username}"], |
| checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"], |
| checkMembershipForUser: ["GET /orgs/{org}/members/{username}"], |
| checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"], |
| convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"], |
| createInvitation: ["POST /orgs/{org}/invitations"], |
| createWebhook: ["POST /orgs/{org}/hooks"], |
| deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], |
| get: ["GET /orgs/{org}"], |
| getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], |
| getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], |
| getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"], |
| list: ["GET /organizations"], |
| listAppInstallations: ["GET /orgs/{org}/installations"], |
| listBlockedUsers: ["GET /orgs/{org}/blocks"], |
| listForAuthenticatedUser: ["GET /user/orgs"], |
| listForUser: ["GET /users/{username}/orgs"], |
| listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"], |
| listMembers: ["GET /orgs/{org}/members"], |
| listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"], |
| listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], |
| listPendingInvitations: ["GET /orgs/{org}/invitations"], |
| listPublicMembers: ["GET /orgs/{org}/public_members"], |
| listWebhooks: ["GET /orgs/{org}/hooks"], |
| pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], |
| removeMember: ["DELETE /orgs/{org}/members/{username}"], |
| removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], |
| removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"], |
| removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"], |
| setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"], |
| setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"], |
| unblockUser: ["DELETE /orgs/{org}/blocks/{username}"], |
| update: ["PATCH /orgs/{org}"], |
| updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"], |
| updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"] |
| }, |
| projects: { |
| addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| createCard: ["POST /projects/columns/{column_id}/cards", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| createColumn: ["POST /projects/{project_id}/columns", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| createForAuthenticatedUser: ["POST /user/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| createForOrg: ["POST /orgs/{org}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| createForRepo: ["POST /repos/{owner}/{repo}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| delete: ["DELETE /projects/{project_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| deleteCard: ["DELETE /projects/columns/cards/{card_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| deleteColumn: ["DELETE /projects/columns/{column_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| get: ["GET /projects/{project_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| getCard: ["GET /projects/columns/cards/{card_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| getColumn: ["GET /projects/columns/{column_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listCards: ["GET /projects/columns/{column_id}/cards", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listCollaborators: ["GET /projects/{project_id}/collaborators", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listColumns: ["GET /projects/{project_id}/columns", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listForOrg: ["GET /orgs/{org}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listForRepo: ["GET /repos/{owner}/{repo}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listForUser: ["GET /users/{username}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| moveCard: ["POST /projects/columns/cards/{card_id}/moves", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| moveColumn: ["POST /projects/columns/{column_id}/moves", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| update: ["PATCH /projects/{project_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| updateCard: ["PATCH /projects/columns/cards/{card_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| updateColumn: ["PATCH /projects/columns/{column_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }] |
| }, |
| pulls: { |
| checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], |
| create: ["POST /repos/{owner}/{repo}/pulls"], |
| createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"], |
| createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], |
| createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"], |
| deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], |
| deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"], |
| dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"], |
| get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], |
| getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], |
| getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], |
| list: ["GET /repos/{owner}/{repo}/pulls"], |
| listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"], |
| listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], |
| listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], |
| listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], |
| listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"], |
| listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], |
| listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], |
| merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], |
| removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], |
| requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], |
| submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"], |
| update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], |
| updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", { |
| mediaType: { |
| previews: ["lydian"] |
| } |
| }], |
| updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], |
| updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] |
| }, |
| rateLimit: { |
| get: ["GET /rate_limit"] |
| }, |
| reactions: { |
| createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| deleteLegacy: ["DELETE /reactions/{reaction_id}", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }, { |
| deprecated: "octokit.reactions.deleteLegacy() is deprecated, see https://developer.github.com/v3/reactions/#delete-a-reaction-legacy" |
| }], |
| listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }], |
| listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { |
| mediaType: { |
| previews: ["squirrel-girl"] |
| } |
| }] |
| }, |
| repos: { |
| acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"], |
| addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { |
| mapToData: "apps" |
| }], |
| addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], |
| addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { |
| mapToData: "contexts" |
| }], |
| addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { |
| mapToData: "teams" |
| }], |
| addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { |
| mapToData: "users" |
| }], |
| checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], |
| checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", { |
| mediaType: { |
| previews: ["dorian"] |
| } |
| }], |
| compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], |
| createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"], |
| createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { |
| mediaType: { |
| previews: ["zzzax"] |
| } |
| }], |
| createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], |
| createDeployKey: ["POST /repos/{owner}/{repo}/keys"], |
| createDeployment: ["POST /repos/{owner}/{repo}/deployments"], |
| createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], |
| createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], |
| createForAuthenticatedUser: ["POST /user/repos"], |
| createFork: ["POST /repos/{owner}/{repo}/forks"], |
| createInOrg: ["POST /orgs/{org}/repos"], |
| createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], |
| createPagesSite: ["POST /repos/{owner}/{repo}/pages", { |
| mediaType: { |
| previews: ["switcheroo"] |
| } |
| }], |
| createRelease: ["POST /repos/{owner}/{repo}/releases"], |
| createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", { |
| mediaType: { |
| previews: ["baptiste"] |
| } |
| }], |
| createWebhook: ["POST /repos/{owner}/{repo}/hooks"], |
| declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"], |
| delete: ["DELETE /repos/{owner}/{repo}"], |
| deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], |
| deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], |
| deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"], |
| deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], |
| deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { |
| mediaType: { |
| previews: ["zzzax"] |
| } |
| }], |
| deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], |
| deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"], |
| deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], |
| deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"], |
| deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages", { |
| mediaType: { |
| previews: ["switcheroo"] |
| } |
| }], |
| deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], |
| deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], |
| deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], |
| deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], |
| disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", { |
| mediaType: { |
| previews: ["london"] |
| } |
| }], |
| disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", { |
| mediaType: { |
| previews: ["dorian"] |
| } |
| }], |
| downloadArchive: ["GET /repos/{owner}/{repo}/{archive_format}/{ref}"], |
| enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes", { |
| mediaType: { |
| previews: ["london"] |
| } |
| }], |
| enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", { |
| mediaType: { |
| previews: ["dorian"] |
| } |
| }], |
| get: ["GET /repos/{owner}/{repo}"], |
| getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], |
| getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], |
| getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], |
| getAllTopics: ["GET /repos/{owner}/{repo}/topics", { |
| mediaType: { |
| previews: ["mercy"] |
| } |
| }], |
| getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], |
| getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], |
| getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"], |
| getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], |
| getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], |
| getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"], |
| getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], |
| getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], |
| getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], |
| getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], |
| getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { |
| mediaType: { |
| previews: ["zzzax"] |
| } |
| }], |
| getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile", { |
| mediaType: { |
| previews: ["black-panther"] |
| } |
| }], |
| getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], |
| getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], |
| getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], |
| getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], |
| getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"], |
| getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], |
| getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], |
| getPages: ["GET /repos/{owner}/{repo}/pages"], |
| getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], |
| getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"], |
| getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], |
| getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"], |
| getReadme: ["GET /repos/{owner}/{repo}/readme"], |
| getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"], |
| getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"], |
| getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"], |
| getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], |
| getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"], |
| getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"], |
| getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"], |
| getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"], |
| getViews: ["GET /repos/{owner}/{repo}/traffic/views"], |
| getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"], |
| listBranches: ["GET /repos/{owner}/{repo}/branches"], |
| listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", { |
| mediaType: { |
| previews: ["groot"] |
| } |
| }], |
| listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], |
| listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"], |
| listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], |
| listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"], |
| listCommits: ["GET /repos/{owner}/{repo}/commits"], |
| listContributors: ["GET /repos/{owner}/{repo}/contributors"], |
| listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], |
| listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], |
| listDeployments: ["GET /repos/{owner}/{repo}/deployments"], |
| listForAuthenticatedUser: ["GET /user/repos"], |
| listForOrg: ["GET /orgs/{org}/repos"], |
| listForUser: ["GET /users/{username}/repos"], |
| listForks: ["GET /repos/{owner}/{repo}/forks"], |
| listInvitations: ["GET /repos/{owner}/{repo}/invitations"], |
| listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], |
| listLanguages: ["GET /repos/{owner}/{repo}/languages"], |
| listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], |
| listPublic: ["GET /repositories"], |
| listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", { |
| mediaType: { |
| previews: ["groot"] |
| } |
| }], |
| listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], |
| listReleases: ["GET /repos/{owner}/{repo}/releases"], |
| listTags: ["GET /repos/{owner}/{repo}/tags"], |
| listTeams: ["GET /repos/{owner}/{repo}/teams"], |
| listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], |
| merge: ["POST /repos/{owner}/{repo}/merges"], |
| pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], |
| removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { |
| mapToData: "apps" |
| }], |
| removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"], |
| removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { |
| mapToData: "contexts" |
| }], |
| removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], |
| removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { |
| mapToData: "teams" |
| }], |
| removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { |
| mapToData: "users" |
| }], |
| replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics", { |
| mediaType: { |
| previews: ["mercy"] |
| } |
| }], |
| requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], |
| setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], |
| setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { |
| mapToData: "apps" |
| }], |
| setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { |
| mapToData: "contexts" |
| }], |
| setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { |
| mapToData: "teams" |
| }], |
| setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { |
| mapToData: "users" |
| }], |
| testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], |
| transfer: ["POST /repos/{owner}/{repo}/transfer"], |
| update: ["PATCH /repos/{owner}/{repo}"], |
| updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"], |
| updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], |
| updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], |
| updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"], |
| updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], |
| updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"], |
| updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"], |
| updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], |
| updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], |
| uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { |
| baseUrl: "https://uploads.github.com" |
| }] |
| }, |
| search: { |
| code: ["GET /search/code"], |
| commits: ["GET /search/commits", { |
| mediaType: { |
| previews: ["cloak"] |
| } |
| }], |
| issuesAndPullRequests: ["GET /search/issues"], |
| labels: ["GET /search/labels"], |
| repos: ["GET /search/repositories"], |
| topics: ["GET /search/topics", { |
| mediaType: { |
| previews: ["mercy"] |
| } |
| }], |
| users: ["GET /search/users"] |
| }, |
| teams: { |
| addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"], |
| addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], |
| checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], |
| create: ["POST /orgs/{org}/teams"], |
| createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], |
| createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], |
| deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], |
| deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], |
| deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], |
| getByName: ["GET /orgs/{org}/teams/{team_slug}"], |
| getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], |
| getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], |
| getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], |
| list: ["GET /orgs/{org}/teams"], |
| listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], |
| listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], |
| listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], |
| listForAuthenticatedUser: ["GET /user/teams"], |
| listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], |
| listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], |
| listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", { |
| mediaType: { |
| previews: ["inertia"] |
| } |
| }], |
| listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], |
| removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], |
| removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"], |
| removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], |
| updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], |
| updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], |
| updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] |
| }, |
| users: { |
| addEmailForAuthenticated: ["POST /user/emails"], |
| block: ["PUT /user/blocks/{username}"], |
| checkBlocked: ["GET /user/blocks/{username}"], |
| checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], |
| checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], |
| createGpgKeyForAuthenticated: ["POST /user/gpg_keys"], |
| createPublicSshKeyForAuthenticated: ["POST /user/keys"], |
| deleteEmailForAuthenticated: ["DELETE /user/emails"], |
| deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"], |
| deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}"], |
| follow: ["PUT /user/following/{username}"], |
| getAuthenticated: ["GET /user"], |
| getByUsername: ["GET /users/{username}"], |
| getContextForUser: ["GET /users/{username}/hovercard"], |
| getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}"], |
| getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"], |
| list: ["GET /users"], |
| listBlockedByAuthenticated: ["GET /user/blocks"], |
| listEmailsForAuthenticated: ["GET /user/emails"], |
| listFollowedByAuthenticated: ["GET /user/following"], |
| listFollowersForAuthenticatedUser: ["GET /user/followers"], |
| listFollowersForUser: ["GET /users/{username}/followers"], |
| listFollowingForUser: ["GET /users/{username}/following"], |
| listGpgKeysForAuthenticated: ["GET /user/gpg_keys"], |
| listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], |
| listPublicEmailsForAuthenticated: ["GET /user/public_emails"], |
| listPublicKeysForUser: ["GET /users/{username}/keys"], |
| listPublicSshKeysForAuthenticated: ["GET /user/keys"], |
| setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"], |
| unblock: ["DELETE /user/blocks/{username}"], |
| unfollow: ["DELETE /user/following/{username}"], |
| updateAuthenticated: ["PATCH /user"] |
| } |
| }; |
| |
| const VERSION = "4.2.1"; |
| |
| function endpointsToMethods(octokit, endpointsMap) { |
| const newMethods = {}; |
| |
| for (const [scope, endpoints] of Object.entries(endpointsMap)) { |
| for (const [methodName, endpoint] of Object.entries(endpoints)) { |
| const [route, defaults, decorations] = endpoint; |
| const [method, url] = route.split(/ /); |
| const endpointDefaults = Object.assign({ |
| method, |
| url |
| }, defaults); |
| |
| if (!newMethods[scope]) { |
| newMethods[scope] = {}; |
| } |
| |
| const scopeMethods = newMethods[scope]; |
| |
| if (decorations) { |
| scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); |
| continue; |
| } |
| |
| scopeMethods[methodName] = octokit.request.defaults(endpointDefaults); |
| } |
| } |
| |
| return newMethods; |
| } |
| |
| function decorate(octokit, scope, methodName, defaults, decorations) { |
| const requestWithDefaults = octokit.request.defaults(defaults); |
| /* istanbul ignore next */ |
| |
| function withDecorations(...args) { |
| // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 |
| let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData` |
| |
| if (decorations.mapToData) { |
| options = Object.assign({}, options, { |
| data: options[decorations.mapToData], |
| [decorations.mapToData]: undefined |
| }); |
| return requestWithDefaults(options); |
| } |
| |
| if (decorations.renamed) { |
| const [newScope, newMethodName] = decorations.renamed; |
| octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`); |
| } |
| |
| if (decorations.deprecated) { |
| octokit.log.warn(decorations.deprecated); |
| } |
| |
| if (decorations.renamedParameters) { |
| // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 |
| const options = requestWithDefaults.endpoint.merge(...args); |
| |
| for (const [name, alias] of Object.entries(decorations.renamedParameters)) { |
| if (name in options) { |
| octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`); |
| |
| if (!(alias in options)) { |
| options[alias] = options[name]; |
| } |
| |
| delete options[name]; |
| } |
| } |
| |
| return requestWithDefaults(options); |
| } // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 |
| |
| |
| return requestWithDefaults(...args); |
| } |
| |
| return Object.assign(withDecorations, requestWithDefaults); |
| } |
| |
| /** |
| * This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary |
| * goal is to rebuild @octokit/rest on top of @octokit/core. Once that is |
| * done, we will remove the registerEndpoints methods and return the methods |
| * directly as with the other plugins. At that point we will also remove the |
| * legacy workarounds and deprecations. |
| * |
| * See the plan at |
| * https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1 |
| */ |
| |
| function restEndpointMethods(octokit) { |
| return endpointsToMethods(octokit, Endpoints); |
| } |
| restEndpointMethods.VERSION = VERSION; |
| |
| exports.restEndpointMethods = restEndpointMethods; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 537: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } |
| |
| var deprecation = __nccwpck_require__(8932); |
| var once = _interopDefault(__nccwpck_require__(1223)); |
| |
| const logOnce = once(deprecation => console.warn(deprecation)); |
| /** |
| * Error with extra properties to help with debugging |
| */ |
| |
| class RequestError extends Error { |
| constructor(message, statusCode, options) { |
| super(message); // Maintains proper stack trace (only available on V8) |
| |
| /* istanbul ignore next */ |
| |
| if (Error.captureStackTrace) { |
| Error.captureStackTrace(this, this.constructor); |
| } |
| |
| this.name = "HttpError"; |
| this.status = statusCode; |
| Object.defineProperty(this, "code", { |
| get() { |
| logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); |
| return statusCode; |
| } |
| |
| }); |
| this.headers = options.headers || {}; // redact request credentials without mutating original request options |
| |
| const requestCopy = Object.assign({}, options.request); |
| |
| if (options.request.headers.authorization) { |
| requestCopy.headers = Object.assign({}, options.request.headers, { |
| authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") |
| }); |
| } |
| |
| requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit |
| // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications |
| .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended |
| // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header |
| .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); |
| this.request = requestCopy; |
| } |
| |
| } |
| |
| exports.RequestError = RequestError; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 6234: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } |
| |
| var endpoint = __nccwpck_require__(9440); |
| var universalUserAgent = __nccwpck_require__(5030); |
| var isPlainObject = __nccwpck_require__(9062); |
| var nodeFetch = _interopDefault(__nccwpck_require__(467)); |
| var requestError = __nccwpck_require__(537); |
| |
| const VERSION = "5.4.10"; |
| |
| function getBufferResponse(response) { |
| return response.arrayBuffer(); |
| } |
| |
| function fetchWrapper(requestOptions) { |
| if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { |
| requestOptions.body = JSON.stringify(requestOptions.body); |
| } |
| |
| let headers = {}; |
| let status; |
| let url; |
| const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch; |
| return fetch(requestOptions.url, Object.assign({ |
| method: requestOptions.method, |
| body: requestOptions.body, |
| headers: requestOptions.headers, |
| redirect: requestOptions.redirect |
| }, requestOptions.request)).then(response => { |
| url = response.url; |
| status = response.status; |
| |
| for (const keyAndValue of response.headers) { |
| headers[keyAndValue[0]] = keyAndValue[1]; |
| } |
| |
| if (status === 204 || status === 205) { |
| return; |
| } // GitHub API returns 200 for HEAD requests |
| |
| |
| if (requestOptions.method === "HEAD") { |
| if (status < 400) { |
| return; |
| } |
| |
| throw new requestError.RequestError(response.statusText, status, { |
| headers, |
| request: requestOptions |
| }); |
| } |
| |
| if (status === 304) { |
| throw new requestError.RequestError("Not modified", status, { |
| headers, |
| request: requestOptions |
| }); |
| } |
| |
| if (status >= 400) { |
| return response.text().then(message => { |
| const error = new requestError.RequestError(message, status, { |
| headers, |
| request: requestOptions |
| }); |
| |
| try { |
| let responseBody = JSON.parse(error.message); |
| Object.assign(error, responseBody); |
| let errors = responseBody.errors; // Assumption `errors` would always be in Array format |
| |
| error.message = error.message + ": " + errors.map(JSON.stringify).join(", "); |
| } catch (e) {// ignore, see octokit/rest.js#684 |
| } |
| |
| throw error; |
| }); |
| } |
| |
| const contentType = response.headers.get("content-type"); |
| |
| if (/application\/json/.test(contentType)) { |
| return response.json(); |
| } |
| |
| if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { |
| return response.text(); |
| } |
| |
| return getBufferResponse(response); |
| }).then(data => { |
| return { |
| status, |
| url, |
| headers, |
| data |
| }; |
| }).catch(error => { |
| if (error instanceof requestError.RequestError) { |
| throw error; |
| } |
| |
| throw new requestError.RequestError(error.message, 500, { |
| headers, |
| request: requestOptions |
| }); |
| }); |
| } |
| |
| function withDefaults(oldEndpoint, newDefaults) { |
| const endpoint = oldEndpoint.defaults(newDefaults); |
| |
| const newApi = function (route, parameters) { |
| const endpointOptions = endpoint.merge(route, parameters); |
| |
| if (!endpointOptions.request || !endpointOptions.request.hook) { |
| return fetchWrapper(endpoint.parse(endpointOptions)); |
| } |
| |
| const request = (route, parameters) => { |
| return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters))); |
| }; |
| |
| Object.assign(request, { |
| endpoint, |
| defaults: withDefaults.bind(null, endpoint) |
| }); |
| return endpointOptions.request.hook(request, endpointOptions); |
| }; |
| |
| return Object.assign(newApi, { |
| endpoint, |
| defaults: withDefaults.bind(null, endpoint) |
| }); |
| } |
| |
| const request = withDefaults(endpoint.endpoint, { |
| headers: { |
| "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}` |
| } |
| }); |
| |
| exports.request = request; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 9062: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| /*! |
| * is-plain-object <https://github.com/jonschlinkert/is-plain-object> |
| * |
| * Copyright (c) 2014-2017, Jon Schlinkert. |
| * Released under the MIT License. |
| */ |
| |
| function isObject(o) { |
| return Object.prototype.toString.call(o) === '[object Object]'; |
| } |
| |
| function isPlainObject(o) { |
| var ctor,prot; |
| |
| if (isObject(o) === false) return false; |
| |
| // If has modified constructor |
| ctor = o.constructor; |
| if (ctor === undefined) return true; |
| |
| // If has modified prototype |
| prot = ctor.prototype; |
| if (isObject(prot) === false) return false; |
| |
| // If constructor does not have an Object-specific method |
| if (prot.hasOwnProperty('isPrototypeOf') === false) { |
| return false; |
| } |
| |
| // Most likely a plain Object |
| return true; |
| } |
| |
| exports.isPlainObject = isPlainObject; |
| |
| |
| /***/ }), |
| |
| /***/ 7678: |
| /***/ ((module, exports) => { |
| |
| "use strict"; |
| |
| /// <reference lib="es2018"/> |
| /// <reference lib="dom"/> |
| /// <reference types="node"/> |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const typedArrayTypeNames = [ |
| 'Int8Array', |
| 'Uint8Array', |
| 'Uint8ClampedArray', |
| 'Int16Array', |
| 'Uint16Array', |
| 'Int32Array', |
| 'Uint32Array', |
| 'Float32Array', |
| 'Float64Array', |
| 'BigInt64Array', |
| 'BigUint64Array' |
| ]; |
| function isTypedArrayName(name) { |
| return typedArrayTypeNames.includes(name); |
| } |
| const objectTypeNames = [ |
| 'Function', |
| 'Generator', |
| 'AsyncGenerator', |
| 'GeneratorFunction', |
| 'AsyncGeneratorFunction', |
| 'AsyncFunction', |
| 'Observable', |
| 'Array', |
| 'Buffer', |
| 'Object', |
| 'RegExp', |
| 'Date', |
| 'Error', |
| 'Map', |
| 'Set', |
| 'WeakMap', |
| 'WeakSet', |
| 'ArrayBuffer', |
| 'SharedArrayBuffer', |
| 'DataView', |
| 'Promise', |
| 'URL', |
| 'HTMLElement', |
| ...typedArrayTypeNames |
| ]; |
| function isObjectTypeName(name) { |
| return objectTypeNames.includes(name); |
| } |
| const primitiveTypeNames = [ |
| 'null', |
| 'undefined', |
| 'string', |
| 'number', |
| 'bigint', |
| 'boolean', |
| 'symbol' |
| ]; |
| function isPrimitiveTypeName(name) { |
| return primitiveTypeNames.includes(name); |
| } |
| // eslint-disable-next-line @typescript-eslint/ban-types |
| function isOfType(type) { |
| return (value) => typeof value === type; |
| } |
| const { toString } = Object.prototype; |
| const getObjectType = (value) => { |
| const objectTypeName = toString.call(value).slice(8, -1); |
| if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) { |
| return 'HTMLElement'; |
| } |
| if (isObjectTypeName(objectTypeName)) { |
| return objectTypeName; |
| } |
| return undefined; |
| }; |
| const isObjectOfType = (type) => (value) => getObjectType(value) === type; |
| function is(value) { |
| if (value === null) { |
| return 'null'; |
| } |
| switch (typeof value) { |
| case 'undefined': |
| return 'undefined'; |
| case 'string': |
| return 'string'; |
| case 'number': |
| return 'number'; |
| case 'boolean': |
| return 'boolean'; |
| case 'function': |
| return 'Function'; |
| case 'bigint': |
| return 'bigint'; |
| case 'symbol': |
| return 'symbol'; |
| default: |
| } |
| if (is.observable(value)) { |
| return 'Observable'; |
| } |
| if (is.array(value)) { |
| return 'Array'; |
| } |
| if (is.buffer(value)) { |
| return 'Buffer'; |
| } |
| const tagType = getObjectType(value); |
| if (tagType) { |
| return tagType; |
| } |
| if (value instanceof String || value instanceof Boolean || value instanceof Number) { |
| throw new TypeError('Please don\'t use object wrappers for primitive types'); |
| } |
| return 'Object'; |
| } |
| is.undefined = isOfType('undefined'); |
| is.string = isOfType('string'); |
| const isNumberType = isOfType('number'); |
| is.number = (value) => isNumberType(value) && !is.nan(value); |
| is.bigint = isOfType('bigint'); |
| // eslint-disable-next-line @typescript-eslint/ban-types |
| is.function_ = isOfType('function'); |
| is.null_ = (value) => value === null; |
| is.class_ = (value) => is.function_(value) && value.toString().startsWith('class '); |
| is.boolean = (value) => value === true || value === false; |
| is.symbol = isOfType('symbol'); |
| is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value)); |
| is.array = (value, assertion) => { |
| if (!Array.isArray(value)) { |
| return false; |
| } |
| if (!is.function_(assertion)) { |
| return true; |
| } |
| return value.every(assertion); |
| }; |
| is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; }; |
| is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value); |
| is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value)); |
| is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); }; |
| is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); }; |
| is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw); |
| is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw); |
| is.nativePromise = (value) => isObjectOfType('Promise')(value); |
| const hasPromiseAPI = (value) => { |
| var _a, _b; |
| return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) && |
| is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch); |
| }; |
| is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value); |
| is.generatorFunction = isObjectOfType('GeneratorFunction'); |
| is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction'; |
| is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction'; |
| // eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types |
| is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype'); |
| is.regExp = isObjectOfType('RegExp'); |
| is.date = isObjectOfType('Date'); |
| is.error = isObjectOfType('Error'); |
| is.map = (value) => isObjectOfType('Map')(value); |
| is.set = (value) => isObjectOfType('Set')(value); |
| is.weakMap = (value) => isObjectOfType('WeakMap')(value); |
| is.weakSet = (value) => isObjectOfType('WeakSet')(value); |
| is.int8Array = isObjectOfType('Int8Array'); |
| is.uint8Array = isObjectOfType('Uint8Array'); |
| is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray'); |
| is.int16Array = isObjectOfType('Int16Array'); |
| is.uint16Array = isObjectOfType('Uint16Array'); |
| is.int32Array = isObjectOfType('Int32Array'); |
| is.uint32Array = isObjectOfType('Uint32Array'); |
| is.float32Array = isObjectOfType('Float32Array'); |
| is.float64Array = isObjectOfType('Float64Array'); |
| is.bigInt64Array = isObjectOfType('BigInt64Array'); |
| is.bigUint64Array = isObjectOfType('BigUint64Array'); |
| is.arrayBuffer = isObjectOfType('ArrayBuffer'); |
| is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer'); |
| is.dataView = isObjectOfType('DataView'); |
| is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype; |
| is.urlInstance = (value) => isObjectOfType('URL')(value); |
| is.urlString = (value) => { |
| if (!is.string(value)) { |
| return false; |
| } |
| try { |
| new URL(value); // eslint-disable-line no-new |
| return true; |
| } |
| catch (_a) { |
| return false; |
| } |
| }; |
| // TODO: Use the `not` operator with a type guard here when it's available. |
| // Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);` |
| is.truthy = (value) => Boolean(value); |
| // Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);` |
| is.falsy = (value) => !value; |
| is.nan = (value) => Number.isNaN(value); |
| is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value); |
| is.integer = (value) => Number.isInteger(value); |
| is.safeInteger = (value) => Number.isSafeInteger(value); |
| is.plainObject = (value) => { |
| // From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js |
| if (toString.call(value) !== '[object Object]') { |
| return false; |
| } |
| const prototype = Object.getPrototypeOf(value); |
| return prototype === null || prototype === Object.getPrototypeOf({}); |
| }; |
| is.typedArray = (value) => isTypedArrayName(getObjectType(value)); |
| const isValidLength = (value) => is.safeInteger(value) && value >= 0; |
| is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length); |
| is.inRange = (value, range) => { |
| if (is.number(range)) { |
| return value >= Math.min(0, range) && value <= Math.max(range, 0); |
| } |
| if (is.array(range) && range.length === 2) { |
| return value >= Math.min(...range) && value <= Math.max(...range); |
| } |
| throw new TypeError(`Invalid range: ${JSON.stringify(range)}`); |
| }; |
| const NODE_TYPE_ELEMENT = 1; |
| const DOM_PROPERTIES_TO_CHECK = [ |
| 'innerHTML', |
| 'ownerDocument', |
| 'style', |
| 'attributes', |
| 'nodeValue' |
| ]; |
| is.domElement = (value) => { |
| return is.object(value) && |
| value.nodeType === NODE_TYPE_ELEMENT && |
| is.string(value.nodeName) && |
| !is.plainObject(value) && |
| DOM_PROPERTIES_TO_CHECK.every(property => property in value); |
| }; |
| is.observable = (value) => { |
| var _a, _b, _c, _d; |
| if (!value) { |
| return false; |
| } |
| // eslint-disable-next-line no-use-extend-native/no-use-extend-native |
| if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) { |
| return true; |
| } |
| if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) { |
| return true; |
| } |
| return false; |
| }; |
| is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value); |
| is.infinite = (value) => value === Infinity || value === -Infinity; |
| const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder; |
| is.evenInteger = isAbsoluteMod2(0); |
| is.oddInteger = isAbsoluteMod2(1); |
| is.emptyArray = (value) => is.array(value) && value.length === 0; |
| is.nonEmptyArray = (value) => is.array(value) && value.length > 0; |
| is.emptyString = (value) => is.string(value) && value.length === 0; |
| // TODO: Use `not ''` when the `not` operator is available. |
| is.nonEmptyString = (value) => is.string(value) && value.length > 0; |
| const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value); |
| is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value); |
| is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0; |
| // TODO: Use `not` operator here to remove `Map` and `Set` from type guard: |
| // - https://github.com/Microsoft/TypeScript/pull/29317 |
| is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0; |
| is.emptySet = (value) => is.set(value) && value.size === 0; |
| is.nonEmptySet = (value) => is.set(value) && value.size > 0; |
| is.emptyMap = (value) => is.map(value) && value.size === 0; |
| is.nonEmptyMap = (value) => is.map(value) && value.size > 0; |
| const predicateOnArray = (method, predicate, values) => { |
| if (!is.function_(predicate)) { |
| throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`); |
| } |
| if (values.length === 0) { |
| throw new TypeError('Invalid number of values'); |
| } |
| return method.call(values, predicate); |
| }; |
| is.any = (predicate, ...values) => { |
| const predicates = is.array(predicate) ? predicate : [predicate]; |
| return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values)); |
| }; |
| is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values); |
| const assertType = (condition, description, value) => { |
| if (!condition) { |
| throw new TypeError(`Expected value which is \`${description}\`, received value of type \`${is(value)}\`.`); |
| } |
| }; |
| exports.assert = { |
| // Unknowns. |
| undefined: (value) => assertType(is.undefined(value), 'undefined', value), |
| string: (value) => assertType(is.string(value), 'string', value), |
| number: (value) => assertType(is.number(value), 'number', value), |
| bigint: (value) => assertType(is.bigint(value), 'bigint', value), |
| // eslint-disable-next-line @typescript-eslint/ban-types |
| function_: (value) => assertType(is.function_(value), 'Function', value), |
| null_: (value) => assertType(is.null_(value), 'null', value), |
| class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value), |
| boolean: (value) => assertType(is.boolean(value), 'boolean', value), |
| symbol: (value) => assertType(is.symbol(value), 'symbol', value), |
| numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value), |
| array: (value, assertion) => { |
| const assert = assertType; |
| assert(is.array(value), 'Array', value); |
| if (assertion) { |
| value.forEach(assertion); |
| } |
| }, |
| buffer: (value) => assertType(is.buffer(value), 'Buffer', value), |
| nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value), |
| object: (value) => assertType(is.object(value), 'Object', value), |
| iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value), |
| asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value), |
| generator: (value) => assertType(is.generator(value), 'Generator', value), |
| asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value), |
| nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value), |
| promise: (value) => assertType(is.promise(value), 'Promise', value), |
| generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value), |
| asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value), |
| // eslint-disable-next-line @typescript-eslint/ban-types |
| asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value), |
| // eslint-disable-next-line @typescript-eslint/ban-types |
| boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value), |
| regExp: (value) => assertType(is.regExp(value), 'RegExp', value), |
| date: (value) => assertType(is.date(value), 'Date', value), |
| error: (value) => assertType(is.error(value), 'Error', value), |
| map: (value) => assertType(is.map(value), 'Map', value), |
| set: (value) => assertType(is.set(value), 'Set', value), |
| weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value), |
| weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value), |
| int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value), |
| uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value), |
| uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value), |
| int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value), |
| uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value), |
| int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value), |
| uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value), |
| float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value), |
| float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value), |
| bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value), |
| bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value), |
| arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value), |
| sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value), |
| dataView: (value) => assertType(is.dataView(value), 'DataView', value), |
| urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value), |
| urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value), |
| truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value), |
| falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value), |
| nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value), |
| primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value), |
| integer: (value) => assertType(is.integer(value), "integer" /* integer */, value), |
| safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value), |
| plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value), |
| typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value), |
| arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value), |
| domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* domElement */, value), |
| observable: (value) => assertType(is.observable(value), 'Observable', value), |
| nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value), |
| infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value), |
| emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value), |
| nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value), |
| emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value), |
| nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value), |
| emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value), |
| emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value), |
| nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value), |
| emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value), |
| nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value), |
| emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value), |
| nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value), |
| // Numbers. |
| evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value), |
| oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value), |
| // Two arguments. |
| directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance), |
| inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value), |
| // Variadic functions. |
| any: (predicate, ...values) => assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values), |
| all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values) |
| }; |
| // Some few keywords are reserved, but we'll populate them for Node.js users |
| // See https://github.com/Microsoft/TypeScript/issues/2536 |
| Object.defineProperties(is, { |
| class: { |
| value: is.class_ |
| }, |
| function: { |
| value: is.function_ |
| }, |
| null: { |
| value: is.null_ |
| } |
| }); |
| Object.defineProperties(exports.assert, { |
| class: { |
| value: exports.assert.class_ |
| }, |
| function: { |
| value: exports.assert.function_ |
| }, |
| null: { |
| value: exports.assert.null_ |
| } |
| }); |
| exports.default = is; |
| // For CommonJS default export support |
| module.exports = is; |
| module.exports.default = is; |
| module.exports.assert = exports.assert; |
| |
| |
| /***/ }), |
| |
| /***/ 8097: |
| /***/ ((module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const defer_to_connect_1 = __nccwpck_require__(6214); |
| const nodejsMajorVersion = Number(process.versions.node.split('.')[0]); |
| const timer = (request) => { |
| const timings = { |
| start: Date.now(), |
| socket: undefined, |
| lookup: undefined, |
| connect: undefined, |
| secureConnect: undefined, |
| upload: undefined, |
| response: undefined, |
| end: undefined, |
| error: undefined, |
| abort: undefined, |
| phases: { |
| wait: undefined, |
| dns: undefined, |
| tcp: undefined, |
| tls: undefined, |
| request: undefined, |
| firstByte: undefined, |
| download: undefined, |
| total: undefined |
| } |
| }; |
| request.timings = timings; |
| const handleError = (origin) => { |
| const emit = origin.emit.bind(origin); |
| origin.emit = (event, ...args) => { |
| // Catches the `error` event |
| if (event === 'error') { |
| timings.error = Date.now(); |
| timings.phases.total = timings.error - timings.start; |
| origin.emit = emit; |
| } |
| // Saves the original behavior |
| return emit(event, ...args); |
| }; |
| }; |
| handleError(request); |
| request.prependOnceListener('abort', () => { |
| timings.abort = Date.now(); |
| // Let the `end` response event be responsible for setting the total phase, |
| // unless the Node.js major version is >= 13. |
| if (!timings.response || nodejsMajorVersion >= 13) { |
| timings.phases.total = Date.now() - timings.start; |
| } |
| }); |
| const onSocket = (socket) => { |
| timings.socket = Date.now(); |
| timings.phases.wait = timings.socket - timings.start; |
| const lookupListener = () => { |
| timings.lookup = Date.now(); |
| timings.phases.dns = timings.lookup - timings.socket; |
| }; |
| socket.prependOnceListener('lookup', lookupListener); |
| defer_to_connect_1.default(socket, { |
| connect: () => { |
| timings.connect = Date.now(); |
| if (timings.lookup === undefined) { |
| socket.removeListener('lookup', lookupListener); |
| timings.lookup = timings.connect; |
| timings.phases.dns = timings.lookup - timings.socket; |
| } |
| timings.phases.tcp = timings.connect - timings.lookup; |
| // This callback is called before flushing any data, |
| // so we don't need to set `timings.phases.request` here. |
| }, |
| secureConnect: () => { |
| timings.secureConnect = Date.now(); |
| timings.phases.tls = timings.secureConnect - timings.connect; |
| } |
| }); |
| }; |
| if (request.socket) { |
| onSocket(request.socket); |
| } |
| else { |
| request.prependOnceListener('socket', onSocket); |
| } |
| const onUpload = () => { |
| var _a; |
| timings.upload = Date.now(); |
| timings.phases.request = timings.upload - (_a = timings.secureConnect, (_a !== null && _a !== void 0 ? _a : timings.connect)); |
| }; |
| const writableFinished = () => { |
| if (typeof request.writableFinished === 'boolean') { |
| return request.writableFinished; |
| } |
| // Node.js doesn't have `request.writableFinished` property |
| return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0); |
| }; |
| if (writableFinished()) { |
| onUpload(); |
| } |
| else { |
| request.prependOnceListener('finish', onUpload); |
| } |
| request.prependOnceListener('response', (response) => { |
| timings.response = Date.now(); |
| timings.phases.firstByte = timings.response - timings.upload; |
| response.timings = timings; |
| handleError(response); |
| response.prependOnceListener('end', () => { |
| timings.end = Date.now(); |
| timings.phases.download = timings.end - timings.response; |
| timings.phases.total = timings.end - timings.start; |
| }); |
| }); |
| return timings; |
| }; |
| exports.default = timer; |
| // For CommonJS default export support |
| module.exports = timer; |
| module.exports.default = timer; |
| |
| |
| /***/ }), |
| |
| /***/ 6761: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var Utils = __nccwpck_require__(5182); |
| var fs = Utils.FileSystem.require(), |
| pth = __nccwpck_require__(5622); |
| |
| fs.existsSync = fs.existsSync || pth.existsSync; |
| |
| var ZipEntry = __nccwpck_require__(4057), |
| ZipFile = __nccwpck_require__(7744); |
| |
| var isWin = /^win/.test(process.platform); |
| |
| function canonical(p) { |
| var safeSuffix = pth.normalize(p).replace(/^(\.\.(\/|\\|$))+/, ''); |
| return pth.join('./', safeSuffix); |
| } |
| |
| module.exports = function (/**String*/input) { |
| var _zip = undefined, |
| _filename = ""; |
| |
| if (input && typeof input === "string") { // load zip file |
| if (fs.existsSync(input)) { |
| _filename = input; |
| _zip = new ZipFile(input, Utils.Constants.FILE); |
| } else { |
| throw new Error(Utils.Errors.INVALID_FILENAME); |
| } |
| } else if (input && Buffer.isBuffer(input)) { // load buffer |
| _zip = new ZipFile(input, Utils.Constants.BUFFER); |
| } else { // create new zip file |
| _zip = new ZipFile(null, Utils.Constants.NONE); |
| } |
| |
| function sanitize(prefix, name) { |
| prefix = pth.resolve(pth.normalize(prefix)); |
| var parts = name.split('/'); |
| for (var i = 0, l = parts.length; i < l; i++) { |
| var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep))); |
| if (path.indexOf(prefix) === 0) { |
| return path; |
| } |
| } |
| return pth.normalize(pth.join(prefix, pth.basename(name))); |
| } |
| |
| function getEntry(/**Object*/entry) { |
| if (entry && _zip) { |
| var item; |
| // If entry was given as a file name |
| if (typeof entry === "string") |
| item = _zip.getEntry(entry); |
| // if entry was given as a ZipEntry object |
| if (typeof entry === "object" && typeof entry.entryName !== "undefined" && typeof entry.header !== "undefined") |
| item = _zip.getEntry(entry.entryName); |
| |
| if (item) { |
| return item; |
| } |
| } |
| return null; |
| } |
| |
| function fixPath(zipPath){ |
| // convert windows file separators and normalize |
| zipPath = pth.posix.normalize(zipPath.split("\\").join("/")); |
| // cleanup, remove invalid folder names |
| var names = zipPath.split("/").filter((c) => c !== "" && c !== "." && c !== ".."); |
| // if we have name we return it |
| return names.length ? names.join("/") + "/" : ""; |
| } |
| |
| return { |
| /** |
| * Extracts the given entry from the archive and returns the content as a Buffer object |
| * @param entry ZipEntry object or String with the full path of the entry |
| * |
| * @return Buffer or Null in case of error |
| */ |
| readFile: function (/**Object*/entry, /*String, Buffer*/pass) { |
| var item = getEntry(entry); |
| return item && item.getData(pass) || null; |
| }, |
| |
| /** |
| * Asynchronous readFile |
| * @param entry ZipEntry object or String with the full path of the entry |
| * @param callback |
| * |
| * @return Buffer or Null in case of error |
| */ |
| readFileAsync: function (/**Object*/entry, /**Function*/callback) { |
| var item = getEntry(entry); |
| if (item) { |
| item.getDataAsync(callback); |
| } else { |
| callback(null, "getEntry failed for:" + entry) |
| } |
| }, |
| |
| /** |
| * Extracts the given entry from the archive and returns the content as plain text in the given encoding |
| * @param entry ZipEntry object or String with the full path of the entry |
| * @param encoding Optional. If no encoding is specified utf8 is used |
| * |
| * @return String |
| */ |
| readAsText: function (/**Object*/entry, /**String=*/encoding) { |
| var item = getEntry(entry); |
| if (item) { |
| var data = item.getData(); |
| if (data && data.length) { |
| return data.toString(encoding || "utf8"); |
| } |
| } |
| return ""; |
| }, |
| |
| /** |
| * Asynchronous readAsText |
| * @param entry ZipEntry object or String with the full path of the entry |
| * @param callback |
| * @param encoding Optional. If no encoding is specified utf8 is used |
| * |
| * @return String |
| */ |
| readAsTextAsync: function (/**Object*/entry, /**Function*/callback, /**String=*/encoding) { |
| var item = getEntry(entry); |
| if (item) { |
| item.getDataAsync(function (data, err) { |
| if (err) { |
| callback(data, err); |
| return; |
| } |
| |
| if (data && data.length) { |
| callback(data.toString(encoding || "utf8")); |
| } else { |
| callback(""); |
| } |
| }) |
| } else { |
| callback(""); |
| } |
| }, |
| |
| /** |
| * Remove the entry from the file or the entry and all it's nested directories and files if the given entry is a directory |
| * |
| * @param entry |
| */ |
| deleteFile: function (/**Object*/entry) { // @TODO: test deleteFile |
| var item = getEntry(entry); |
| if (item) { |
| _zip.deleteEntry(item.entryName); |
| } |
| }, |
| |
| /** |
| * Adds a comment to the zip. The zip must be rewritten after adding the comment. |
| * |
| * @param comment |
| */ |
| addZipComment: function (/**String*/comment) { // @TODO: test addZipComment |
| _zip.comment = comment; |
| }, |
| |
| /** |
| * Returns the zip comment |
| * |
| * @return String |
| */ |
| getZipComment: function () { |
| return _zip.comment || ''; |
| }, |
| |
| /** |
| * Adds a comment to a specified zipEntry. The zip must be rewritten after adding the comment |
| * The comment cannot exceed 65535 characters in length |
| * |
| * @param entry |
| * @param comment |
| */ |
| addZipEntryComment: function (/**Object*/entry, /**String*/comment) { |
| var item = getEntry(entry); |
| if (item) { |
| item.comment = comment; |
| } |
| }, |
| |
| /** |
| * Returns the comment of the specified entry |
| * |
| * @param entry |
| * @return String |
| */ |
| getZipEntryComment: function (/**Object*/entry) { |
| var item = getEntry(entry); |
| if (item) { |
| return item.comment || ''; |
| } |
| return '' |
| }, |
| |
| /** |
| * Updates the content of an existing entry inside the archive. The zip must be rewritten after updating the content |
| * |
| * @param entry |
| * @param content |
| */ |
| updateFile: function (/**Object*/entry, /**Buffer*/content) { |
| var item = getEntry(entry); |
| if (item) { |
| item.setData(content); |
| } |
| }, |
| |
| /** |
| * Adds a file from the disk to the archive |
| * |
| * @param localPath File to add to zip |
| * @param zipPath Optional path inside the zip |
| * @param zipName Optional name for the file |
| */ |
| addLocalFile: function (/**String*/localPath, /**String=*/zipPath, /**String=*/zipName, /**String*/comment) { |
| if (fs.existsSync(localPath)) { |
| // fix ZipPath |
| zipPath = (zipPath) ? fixPath(zipPath) : ""; |
| |
| // p - local file name |
| var p = localPath.split("\\").join("/").split("/").pop(); |
| |
| // add file name into zippath |
| zipPath += (zipName) ? zipName : p; |
| |
| // read file attributes |
| const _attr = fs.statSync(localPath); |
| |
| // add file into zip file |
| this.addFile(zipPath, fs.readFileSync(localPath), comment, _attr) |
| } else { |
| throw new Error(Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath)); |
| } |
| }, |
| |
| /** |
| * Adds a local directory and all its nested files and directories to the archive |
| * |
| * @param localPath |
| * @param zipPath optional path inside zip |
| * @param filter optional RegExp or Function if files match will |
| * be included. |
| */ |
| addLocalFolder: function (/**String*/localPath, /**String=*/zipPath, /**=RegExp|Function*/filter) { |
| // Prepare filter |
| if (filter instanceof RegExp) { // if filter is RegExp wrap it |
| filter = (function (rx){ |
| return function (filename) { |
| return rx.test(filename); |
| } |
| })(filter); |
| } else if ('function' !== typeof filter) { // if filter is not function we will replace it |
| filter = function () { |
| return true; |
| }; |
| } |
| |
| // fix ZipPath |
| zipPath = (zipPath) ? fixPath(zipPath) : ""; |
| |
| // normalize the path first |
| localPath = pth.normalize(localPath); |
| |
| if (fs.existsSync(localPath)) { |
| |
| var items = Utils.findFiles(localPath), |
| self = this; |
| |
| if (items.length) { |
| items.forEach(function (filepath) { |
| var p = pth.relative(localPath, filepath).split("\\").join("/"); //windows fix |
| if (filter(p)) { |
| var stats = fs.statSync(filepath); |
| if (stats.isFile()) { |
| self.addFile(zipPath + p, fs.readFileSync(filepath), "", stats); |
| } else { |
| self.addFile(zipPath + p + '/', Buffer.alloc(0), "", stats); |
| } |
| } |
| }); |
| } |
| } else { |
| throw new Error(Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath)); |
| } |
| }, |
| |
| /** |
| * Asynchronous addLocalFile |
| * @param localPath |
| * @param callback |
| * @param zipPath optional path inside zip |
| * @param filter optional RegExp or Function if files match will |
| * be included. |
| */ |
| addLocalFolderAsync: function (/*String*/localPath, /*Function*/callback, /*String*/zipPath, /*RegExp|Function*/filter) { |
| if (filter instanceof RegExp) { |
| filter = (function (rx) { |
| return function (filename) { |
| return rx.test(filename); |
| }; |
| })(filter); |
| } else if ("function" !== typeof filter) { |
| filter = function () { |
| return true; |
| }; |
| } |
| |
| // fix ZipPath |
| zipPath = zipPath ? fixPath(zipPath) : ""; |
| |
| // normalize the path first |
| localPath = pth.normalize(localPath); |
| |
| var self = this; |
| fs.open(localPath, 'r', function (err) { |
| if (err && err.code === 'ENOENT') { |
| callback(undefined, Utils.Errors.FILE_NOT_FOUND.replace("%s", localPath)); |
| } else if (err) { |
| callback(undefined, err); |
| } else { |
| var items = Utils.findFiles(localPath); |
| var i = -1; |
| |
| var next = function () { |
| i += 1; |
| if (i < items.length) { |
| var filepath = items[i]; |
| var p = pth.relative(localPath, filepath).split("\\").join("/"); //windows fix |
| p = p.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\x20-\x7E]/g, '') // accent fix |
| if (filter(p)) { |
| fs.stat(filepath, function (er0, stats) { |
| if (er0) callback(undefined, er0); |
| if (stats.isFile()) { |
| fs.readFile(filepath, function (er1, data) { |
| if (er1) { |
| callback(undefined, er1); |
| } else { |
| self.addFile(zipPath + p, data, "", stats); |
| next(); |
| } |
| }); |
| } else { |
| self.addFile(zipPath + p + "/", Buffer.alloc(0), "", stats); |
| next(); |
| } |
| }); |
| } else { |
| next(); |
| } |
| |
| } else { |
| callback(true, undefined); |
| } |
| } |
| |
| next(); |
| } |
| }); |
| }, |
| |
| addLocalFolderPromise: function (/*String*/ localPath, /* object */ options) { |
| return new Promise((resolve, reject) => { |
| const { filter, zipPath } = Object.assign({}, options); |
| this.addLocalFolderAsync(localPath, |
| (done, err) => { |
| if (err) reject(err); |
| if (done) resolve(this); |
| }, zipPath, filter |
| ); |
| }); |
| }, |
| |
| /** |
| * Allows you to create a entry (file or directory) in the zip file. |
| * If you want to create a directory the entryName must end in / and a null buffer should be provided. |
| * Comment and attributes are optional |
| * |
| * @param entryName |
| * @param content |
| * @param comment |
| * @param attr |
| */ |
| addFile: function (/**String*/entryName, /**Buffer*/content, /**String*/comment, /**Number*/attr) { |
| // prepare new entry |
| var entry = new ZipEntry(); |
| entry.entryName = entryName; |
| entry.comment = comment || ""; |
| |
| var isStat = ('object' === typeof attr) && (attr instanceof fs.Stats); |
| |
| // last modification time from file stats |
| if (isStat){ |
| entry.header.time = attr.mtime; |
| } |
| |
| // Set file attribute |
| var fileattr = (entry.isDirectory) ? 0x10 : 0; // (MS-DOS directory flag) |
| |
| // extended attributes field for Unix |
| if('win32' !== process.platform){ |
| // set file type either S_IFDIR / S_IFREG |
| var unix = (entry.isDirectory) ? 0x4000 : 0x8000; |
| |
| if (isStat) { // File attributes from file stats |
| unix |= (0xfff & attr.mode); |
| }else if ('number' === typeof attr){ // attr from given attr values |
| unix |= (0xfff & attr); |
| }else{ // Default values: |
| unix |= (entry.isDirectory) ? 0o755 : 0o644; // permissions (drwxr-xr-x) or (-r-wr--r--) |
| } |
| |
| fileattr = (fileattr | (unix << 16)) >>> 0; // add attributes |
| } |
| |
| entry.attr = fileattr; |
| |
| entry.setData(content); |
| _zip.setEntry(entry); |
| }, |
| |
| /** |
| * Returns an array of ZipEntry objects representing the files and folders inside the archive |
| * |
| * @return Array |
| */ |
| getEntries: function () { |
| if (_zip) { |
| return _zip.entries; |
| } else { |
| return []; |
| } |
| }, |
| |
| /** |
| * Returns a ZipEntry object representing the file or folder specified by ``name``. |
| * |
| * @param name |
| * @return ZipEntry |
| */ |
| getEntry: function (/**String*/name) { |
| return getEntry(name); |
| }, |
| |
| getEntryCount: function() { |
| return _zip.getEntryCount(); |
| }, |
| |
| forEach: function(callback) { |
| return _zip.forEach(callback); |
| }, |
| |
| /** |
| * Extracts the given entry to the given targetPath |
| * If the entry is a directory inside the archive, the entire directory and it's subdirectories will be extracted |
| * |
| * @param entry ZipEntry object or String with the full path of the entry |
| * @param targetPath Target folder where to write the file |
| * @param maintainEntryPath If maintainEntryPath is true and the entry is inside a folder, the entry folder |
| * will be created in targetPath as well. Default is TRUE |
| * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true. |
| * Default is FALSE |
| * @param outFileName String If set will override the filename of the extracted file (Only works if the entry is a file) |
| * |
| * @return Boolean |
| */ |
| extractEntryTo: function (/**Object*/entry, /**String*/targetPath, /**Boolean*/maintainEntryPath, /**Boolean*/overwrite, /**String**/outFileName) { |
| overwrite = overwrite || false; |
| maintainEntryPath = typeof maintainEntryPath === "undefined" ? true : maintainEntryPath; |
| |
| var item = getEntry(entry); |
| if (!item) { |
| throw new Error(Utils.Errors.NO_ENTRY); |
| } |
| |
| var entryName = canonical(item.entryName); |
| |
| var target = sanitize(targetPath,outFileName && !item.isDirectory ? outFileName : (maintainEntryPath ? entryName : pth.basename(entryName))); |
| |
| if (item.isDirectory) { |
| target = pth.resolve(target, ".."); |
| var children = _zip.getEntryChildren(item); |
| children.forEach(function (child) { |
| if (child.isDirectory) return; |
| var content = child.getData(); |
| if (!content) { |
| throw new Error(Utils.Errors.CANT_EXTRACT_FILE); |
| } |
| var name = canonical(child.entryName) |
| var childName = sanitize(targetPath, maintainEntryPath ? name : pth.basename(name)); |
| // The reverse operation for attr depend on method addFile() |
| var fileAttr = child.attr ? (((child.attr >>> 0) | 0) >> 16) & 0xfff : 0; |
| Utils.writeFileTo(childName, content, overwrite, fileAttr); |
| }); |
| return true; |
| } |
| |
| var content = item.getData(); |
| if (!content) throw new Error(Utils.Errors.CANT_EXTRACT_FILE); |
| |
| if (fs.existsSync(target) && !overwrite) { |
| throw new Error(Utils.Errors.CANT_OVERRIDE); |
| } |
| // The reverse operation for attr depend on method addFile() |
| var fileAttr = item.attr ? (((item.attr >>> 0) | 0) >> 16) & 0xfff : 0; |
| Utils.writeFileTo(target, content, overwrite, fileAttr); |
| |
| return true; |
| }, |
| |
| /** |
| * Test the archive |
| * |
| */ |
| test: function (pass) { |
| if (!_zip) { |
| return false; |
| } |
| |
| for (var entry in _zip.entries) { |
| try { |
| if (entry.isDirectory) { |
| continue; |
| } |
| var content = _zip.entries[entry].getData(pass); |
| if (!content) { |
| return false; |
| } |
| } catch (err) { |
| return false; |
| } |
| } |
| return true; |
| }, |
| |
| /** |
| * Extracts the entire archive to the given location |
| * |
| * @param targetPath Target location |
| * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true. |
| * Default is FALSE |
| */ |
| extractAllTo: function (/**String*/targetPath, /**Boolean*/overwrite, /*String, Buffer*/pass) { |
| overwrite = overwrite || false; |
| if (!_zip) { |
| throw new Error(Utils.Errors.NO_ZIP); |
| } |
| _zip.entries.forEach(function (entry) { |
| var entryName = sanitize(targetPath, canonical(entry.entryName.toString())); |
| if (entry.isDirectory) { |
| Utils.makeDir(entryName); |
| return; |
| } |
| var content = entry.getData(pass); |
| if (!content) { |
| throw new Error(Utils.Errors.CANT_EXTRACT_FILE); |
| } |
| // The reverse operation for attr depend on method addFile() |
| var fileAttr = entry.attr ? (((entry.attr >>> 0) | 0) >> 16) & 0xfff : 0; |
| Utils.writeFileTo(entryName, content, overwrite, fileAttr); |
| try { |
| fs.utimesSync(entryName, entry.header.time, entry.header.time) |
| } catch (err) { |
| throw new Error(Utils.Errors.CANT_EXTRACT_FILE); |
| } |
| }) |
| }, |
| |
| /** |
| * Asynchronous extractAllTo |
| * |
| * @param targetPath Target location |
| * @param overwrite If the file already exists at the target path, the file will be overwriten if this is true. |
| * Default is FALSE |
| * @param callback |
| */ |
| extractAllToAsync: function (/**String*/targetPath, /**Boolean*/overwrite, /**Function*/callback) { |
| if (!callback) { |
| callback = function() {} |
| } |
| overwrite = overwrite || false; |
| if (!_zip) { |
| callback(new Error(Utils.Errors.NO_ZIP)); |
| return; |
| } |
| |
| var entries = _zip.entries; |
| var i = entries.length; |
| entries.forEach(function (entry) { |
| if (i <= 0) return; // Had an error already |
| |
| var entryName = pth.normalize(canonical(entry.entryName.toString())); |
| |
| if (entry.isDirectory) { |
| Utils.makeDir(sanitize(targetPath, entryName)); |
| if (--i === 0) |
| callback(undefined); |
| return; |
| } |
| entry.getDataAsync(function (content, err) { |
| if (i <= 0) return; |
| if (err) { |
| callback(new Error(err)); |
| return; |
| } |
| if (!content) { |
| i = 0; |
| callback(new Error(Utils.Errors.CANT_EXTRACT_FILE)); |
| return; |
| } |
| |
| // The reverse operation for attr depend on method addFile() |
| var fileAttr = entry.attr ? (((entry.attr >>> 0) | 0) >> 16) & 0xfff : 0; |
| Utils.writeFileToAsync(sanitize(targetPath, entryName), content, overwrite, fileAttr, function (succ) { |
| try { |
| fs.utimesSync(pth.resolve(targetPath, entryName), entry.header.time, entry.header.time); |
| } catch (err) { |
| callback(new Error('Unable to set utimes')); |
| } |
| if (i <= 0) return; |
| if (!succ) { |
| i = 0; |
| callback(new Error('Unable to write')); |
| return; |
| } |
| if (--i === 0) |
| callback(undefined); |
| }); |
| }); |
| }) |
| }, |
| |
| /** |
| * Writes the newly created zip file to disk at the specified location or if a zip was opened and no ``targetFileName`` is provided, it will overwrite the opened zip |
| * |
| * @param targetFileName |
| * @param callback |
| */ |
| writeZip: function (/**String*/targetFileName, /**Function*/callback) { |
| if (arguments.length === 1) { |
| if (typeof targetFileName === "function") { |
| callback = targetFileName; |
| targetFileName = ""; |
| } |
| } |
| |
| if (!targetFileName && _filename) { |
| targetFileName = _filename; |
| } |
| if (!targetFileName) return; |
| |
| var zipData = _zip.compressToBuffer(); |
| if (zipData) { |
| var ok = Utils.writeFileTo(targetFileName, zipData, true); |
| if (typeof callback === 'function') callback(!ok ? new Error("failed") : null, ""); |
| } |
| }, |
| |
| writeZipPromise: function (/**String*/ targetFileName, /* object */ options) { |
| const { overwrite, perm } = Object.assign({ overwrite: true }, options); |
| |
| return new Promise((resolve, reject) => { |
| // find file name |
| if (!targetFileName && _filename) targetFileName = _filename; |
| if (!targetFileName) reject("ADM-ZIP: ZIP File Name Missing"); |
| |
| this.toBufferPromise().then((zipData) => { |
| const ret = (done) => (done ? resolve(done) : reject("ADM-ZIP: Wasn't able to write zip file")); |
| Utils.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret); |
| }, reject); |
| }); |
| }, |
| |
| toBufferPromise: function () { |
| return new Promise((resolve, reject) => { |
| _zip.toAsyncBuffer(resolve, reject); |
| }); |
| }, |
| |
| /** |
| * Returns the content of the entire zip file as a Buffer object |
| * |
| * @return Buffer |
| */ |
| toBuffer: function (/**Function=*/onSuccess, /**Function=*/onFail, /**Function=*/onItemStart, /**Function=*/onItemEnd) { |
| this.valueOf = 2; |
| if (typeof onSuccess === "function") { |
| _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd); |
| return null; |
| } |
| return _zip.compressToBuffer() |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 9032: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var Utils = __nccwpck_require__(5182), |
| Constants = Utils.Constants; |
| |
| /* The central directory file header */ |
| module.exports = function () { |
| var _verMade = 0x14, |
| _version = 0x0A, |
| _flags = 0, |
| _method = 0, |
| _time = 0, |
| _crc = 0, |
| _compressedSize = 0, |
| _size = 0, |
| _fnameLen = 0, |
| _extraLen = 0, |
| |
| _comLen = 0, |
| _diskStart = 0, |
| _inattr = 0, |
| _attr = 0, |
| _offset = 0; |
| |
| switch(process.platform){ |
| case 'win32': |
| _verMade |= 0x0A00; |
| case 'darwin': |
| _verMade |= 0x1300; |
| default: |
| _verMade |= 0x0300; |
| } |
| |
| var _dataHeader = {}; |
| |
| function setTime(val) { |
| val = new Date(val); |
| _time = (val.getFullYear() - 1980 & 0x7f) << 25 // b09-16 years from 1980 |
| | (val.getMonth() + 1) << 21 // b05-08 month |
| | val.getDate() << 16 // b00-04 hour |
| |
| // 2 bytes time |
| | val.getHours() << 11 // b11-15 hour |
| | val.getMinutes() << 5 // b05-10 minute |
| | val.getSeconds() >> 1; // b00-04 seconds divided by 2 |
| } |
| |
| setTime(+new Date()); |
| |
| return { |
| get made () { return _verMade; }, |
| set made (val) { _verMade = val; }, |
| |
| get version () { return _version; }, |
| set version (val) { _version = val }, |
| |
| get flags () { return _flags }, |
| set flags (val) { _flags = val; }, |
| |
| get method () { return _method; }, |
| set method (val) { |
| switch (val){ |
| case Constants.STORED: |
| this.version = 10; |
| case Constants.DEFLATED: |
| default: |
| this.version = 20; |
| } |
| _method = val; |
| }, |
| |
| get time () { return new Date( |
| ((_time >> 25) & 0x7f) + 1980, |
| ((_time >> 21) & 0x0f) - 1, |
| (_time >> 16) & 0x1f, |
| (_time >> 11) & 0x1f, |
| (_time >> 5) & 0x3f, |
| (_time & 0x1f) << 1 |
| ); |
| }, |
| set time (val) { |
| setTime(val); |
| }, |
| |
| get crc () { return _crc; }, |
| set crc (val) { _crc = val; }, |
| |
| get compressedSize () { return _compressedSize; }, |
| set compressedSize (val) { _compressedSize = val; }, |
| |
| get size () { return _size; }, |
| set size (val) { _size = val; }, |
| |
| get fileNameLength () { return _fnameLen; }, |
| set fileNameLength (val) { _fnameLen = val; }, |
| |
| get extraLength () { return _extraLen }, |
| set extraLength (val) { _extraLen = val; }, |
| |
| get commentLength () { return _comLen }, |
| set commentLength (val) { _comLen = val }, |
| |
| get diskNumStart () { return _diskStart }, |
| set diskNumStart (val) { _diskStart = val }, |
| |
| get inAttr () { return _inattr }, |
| set inAttr (val) { _inattr = val }, |
| |
| get attr () { return _attr }, |
| set attr (val) { _attr = val }, |
| |
| get offset () { return _offset }, |
| set offset (val) { _offset = val }, |
| |
| get encripted () { return (_flags & 1) === 1 }, |
| |
| get entryHeaderSize () { |
| return Constants.CENHDR + _fnameLen + _extraLen + _comLen; |
| }, |
| |
| get realDataOffset () { |
| return _offset + Constants.LOCHDR + _dataHeader.fnameLen + _dataHeader.extraLen; |
| }, |
| |
| get dataHeader () { |
| return _dataHeader; |
| }, |
| |
| loadDataHeaderFromBinary : function(/*Buffer*/input) { |
| var data = input.slice(_offset, _offset + Constants.LOCHDR); |
| // 30 bytes and should start with "PK\003\004" |
| if (data.readUInt32LE(0) !== Constants.LOCSIG) { |
| throw new Error(Utils.Errors.INVALID_LOC); |
| } |
| _dataHeader = { |
| // version needed to extract |
| version : data.readUInt16LE(Constants.LOCVER), |
| // general purpose bit flag |
| flags : data.readUInt16LE(Constants.LOCFLG), |
| // compression method |
| method : data.readUInt16LE(Constants.LOCHOW), |
| // modification time (2 bytes time, 2 bytes date) |
| time : data.readUInt32LE(Constants.LOCTIM), |
| // uncompressed file crc-32 value |
| crc : data.readUInt32LE(Constants.LOCCRC), |
| // compressed size |
| compressedSize : data.readUInt32LE(Constants.LOCSIZ), |
| // uncompressed size |
| size : data.readUInt32LE(Constants.LOCLEN), |
| // filename length |
| fnameLen : data.readUInt16LE(Constants.LOCNAM), |
| // extra field length |
| extraLen : data.readUInt16LE(Constants.LOCEXT) |
| } |
| }, |
| |
| loadFromBinary : function(/*Buffer*/data) { |
| // data should be 46 bytes and start with "PK 01 02" |
| if (data.length !== Constants.CENHDR || data.readUInt32LE(0) !== Constants.CENSIG) { |
| throw new Error(Utils.Errors.INVALID_CEN); |
| } |
| // version made by |
| _verMade = data.readUInt16LE(Constants.CENVEM); |
| // version needed to extract |
| _version = data.readUInt16LE(Constants.CENVER); |
| // encrypt, decrypt flags |
| _flags = data.readUInt16LE(Constants.CENFLG); |
| // compression method |
| _method = data.readUInt16LE(Constants.CENHOW); |
| // modification time (2 bytes time, 2 bytes date) |
| _time = data.readUInt32LE(Constants.CENTIM); |
| // uncompressed file crc-32 value |
| _crc = data.readUInt32LE(Constants.CENCRC); |
| // compressed size |
| _compressedSize = data.readUInt32LE(Constants.CENSIZ); |
| // uncompressed size |
| _size = data.readUInt32LE(Constants.CENLEN); |
| // filename length |
| _fnameLen = data.readUInt16LE(Constants.CENNAM); |
| // extra field length |
| _extraLen = data.readUInt16LE(Constants.CENEXT); |
| // file comment length |
| _comLen = data.readUInt16LE(Constants.CENCOM); |
| // volume number start |
| _diskStart = data.readUInt16LE(Constants.CENDSK); |
| // internal file attributes |
| _inattr = data.readUInt16LE(Constants.CENATT); |
| // external file attributes |
| _attr = data.readUInt32LE(Constants.CENATX); |
| // LOC header offset |
| _offset = data.readUInt32LE(Constants.CENOFF); |
| }, |
| |
| dataHeaderToBinary : function() { |
| // LOC header size (30 bytes) |
| var data = Buffer.alloc(Constants.LOCHDR); |
| // "PK\003\004" |
| data.writeUInt32LE(Constants.LOCSIG, 0); |
| // version needed to extract |
| data.writeUInt16LE(_version, Constants.LOCVER); |
| // general purpose bit flag |
| data.writeUInt16LE(_flags, Constants.LOCFLG); |
| // compression method |
| data.writeUInt16LE(_method, Constants.LOCHOW); |
| // modification time (2 bytes time, 2 bytes date) |
| data.writeUInt32LE(_time, Constants.LOCTIM); |
| // uncompressed file crc-32 value |
| data.writeUInt32LE(_crc, Constants.LOCCRC); |
| // compressed size |
| data.writeUInt32LE(_compressedSize, Constants.LOCSIZ); |
| // uncompressed size |
| data.writeUInt32LE(_size, Constants.LOCLEN); |
| // filename length |
| data.writeUInt16LE(_fnameLen, Constants.LOCNAM); |
| // extra field length |
| data.writeUInt16LE(_extraLen, Constants.LOCEXT); |
| return data; |
| }, |
| |
| entryHeaderToBinary : function() { |
| // CEN header size (46 bytes) |
| var data = Buffer.alloc(Constants.CENHDR + _fnameLen + _extraLen + _comLen); |
| // "PK\001\002" |
| data.writeUInt32LE(Constants.CENSIG, 0); |
| // version made by |
| data.writeUInt16LE(_verMade, Constants.CENVEM); |
| // version needed to extract |
| data.writeUInt16LE(_version, Constants.CENVER); |
| // encrypt, decrypt flags |
| data.writeUInt16LE(_flags, Constants.CENFLG); |
| // compression method |
| data.writeUInt16LE(_method, Constants.CENHOW); |
| // modification time (2 bytes time, 2 bytes date) |
| data.writeUInt32LE(_time, Constants.CENTIM); |
| // uncompressed file crc-32 value |
| data.writeUInt32LE(_crc, Constants.CENCRC); |
| // compressed size |
| data.writeUInt32LE(_compressedSize, Constants.CENSIZ); |
| // uncompressed size |
| data.writeUInt32LE(_size, Constants.CENLEN); |
| // filename length |
| data.writeUInt16LE(_fnameLen, Constants.CENNAM); |
| // extra field length |
| data.writeUInt16LE(_extraLen, Constants.CENEXT); |
| // file comment length |
| data.writeUInt16LE(_comLen, Constants.CENCOM); |
| // volume number start |
| data.writeUInt16LE(_diskStart, Constants.CENDSK); |
| // internal file attributes |
| data.writeUInt16LE(_inattr, Constants.CENATT); |
| // external file attributes |
| data.writeUInt32LE(_attr, Constants.CENATX); |
| // LOC header offset |
| data.writeUInt32LE(_offset, Constants.CENOFF); |
| // fill all with |
| data.fill(0x00, Constants.CENHDR); |
| return data; |
| }, |
| |
| toString : function() { |
| return '{\n' + |
| '\t"made" : ' + _verMade + ",\n" + |
| '\t"version" : ' + _version + ",\n" + |
| '\t"flags" : ' + _flags + ",\n" + |
| '\t"method" : ' + Utils.methodToString(_method) + ",\n" + |
| '\t"time" : ' + this.time + ",\n" + |
| '\t"crc" : 0x' + _crc.toString(16).toUpperCase() + ",\n" + |
| '\t"compressedSize" : ' + _compressedSize + " bytes,\n" + |
| '\t"size" : ' + _size + " bytes,\n" + |
| '\t"fileNameLength" : ' + _fnameLen + ",\n" + |
| '\t"extraLength" : ' + _extraLen + " bytes,\n" + |
| '\t"commentLength" : ' + _comLen + " bytes,\n" + |
| '\t"diskNumStart" : ' + _diskStart + ",\n" + |
| '\t"inAttr" : ' + _inattr + ",\n" + |
| '\t"attr" : ' + _attr + ",\n" + |
| '\t"offset" : ' + _offset + ",\n" + |
| '\t"entryHeaderSize" : ' + (Constants.CENHDR + _fnameLen + _extraLen + _comLen) + " bytes\n" + |
| '}'; |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 4958: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| exports.EntryHeader = __nccwpck_require__(9032); |
| exports.MainHeader = __nccwpck_require__(4408); |
| |
| |
| /***/ }), |
| |
| /***/ 4408: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var Utils = __nccwpck_require__(5182), |
| Constants = Utils.Constants; |
| |
| /* The entries in the end of central directory */ |
| module.exports = function () { |
| var _volumeEntries = 0, |
| _totalEntries = 0, |
| _size = 0, |
| _offset = 0, |
| _commentLength = 0; |
| |
| return { |
| get diskEntries () { return _volumeEntries }, |
| set diskEntries (/*Number*/val) { _volumeEntries = _totalEntries = val; }, |
| |
| get totalEntries () { return _totalEntries }, |
| set totalEntries (/*Number*/val) { _totalEntries = _volumeEntries = val; }, |
| |
| get size () { return _size }, |
| set size (/*Number*/val) { _size = val; }, |
| |
| get offset () { return _offset }, |
| set offset (/*Number*/val) { _offset = val; }, |
| |
| get commentLength () { return _commentLength }, |
| set commentLength (/*Number*/val) { _commentLength = val; }, |
| |
| get mainHeaderSize () { |
| return Constants.ENDHDR + _commentLength; |
| }, |
| |
| loadFromBinary : function(/*Buffer*/data) { |
| // data should be 22 bytes and start with "PK 05 06" |
| // or be 56+ bytes and start with "PK 06 06" for Zip64 |
| if ((data.length !== Constants.ENDHDR || data.readUInt32LE(0) !== Constants.ENDSIG) && |
| (data.length < Constants.ZIP64HDR || data.readUInt32LE(0) !== Constants.ZIP64SIG)) { |
| |
| throw new Error(Utils.Errors.INVALID_END); |
| } |
| |
| if (data.readUInt32LE(0) === Constants.ENDSIG) { |
| // number of entries on this volume |
| _volumeEntries = data.readUInt16LE(Constants.ENDSUB); |
| // total number of entries |
| _totalEntries = data.readUInt16LE(Constants.ENDTOT); |
| // central directory size in bytes |
| _size = data.readUInt32LE(Constants.ENDSIZ); |
| // offset of first CEN header |
| _offset = data.readUInt32LE(Constants.ENDOFF); |
| // zip file comment length |
| _commentLength = data.readUInt16LE(Constants.ENDCOM); |
| } else { |
| // number of entries on this volume |
| _volumeEntries = Utils.readBigUInt64LE(data, Constants.ZIP64SUB); |
| // total number of entries |
| _totalEntries = Utils.readBigUInt64LE(data, Constants.ZIP64TOT); |
| // central directory size in bytes |
| _size = Utils.readBigUInt64LE(data, Constants.ZIP64SIZ); |
| // offset of first CEN header |
| _offset = Utils.readBigUInt64LE(data, Constants.ZIP64OFF); |
| |
| _commentLength = 0; |
| } |
| |
| }, |
| |
| toBinary : function() { |
| var b = Buffer.alloc(Constants.ENDHDR + _commentLength); |
| // "PK 05 06" signature |
| b.writeUInt32LE(Constants.ENDSIG, 0); |
| b.writeUInt32LE(0, 4); |
| // number of entries on this volume |
| b.writeUInt16LE(_volumeEntries, Constants.ENDSUB); |
| // total number of entries |
| b.writeUInt16LE(_totalEntries, Constants.ENDTOT); |
| // central directory size in bytes |
| b.writeUInt32LE(_size, Constants.ENDSIZ); |
| // offset of first CEN header |
| b.writeUInt32LE(_offset, Constants.ENDOFF); |
| // zip file comment length |
| b.writeUInt16LE(_commentLength, Constants.ENDCOM); |
| // fill comment memory with spaces so no garbage is left there |
| b.fill(" ", Constants.ENDHDR); |
| |
| return b; |
| }, |
| |
| toString : function() { |
| return '{\n' + |
| '\t"diskEntries" : ' + _volumeEntries + ",\n" + |
| '\t"totalEntries" : ' + _totalEntries + ",\n" + |
| '\t"size" : ' + _size + " bytes,\n" + |
| '\t"offset" : 0x' + _offset.toString(16).toUpperCase() + ",\n" + |
| '\t"commentLength" : 0x' + _commentLength + "\n" + |
| '}'; |
| } |
| } |
| }; |
| |
| /***/ }), |
| |
| /***/ 7686: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| module.exports = function (/*Buffer*/inbuf) { |
| |
| var zlib = __nccwpck_require__(8761); |
| |
| var opts = {chunkSize: (parseInt(inbuf.length / 1024) + 1) * 1024}; |
| |
| return { |
| deflate: function () { |
| return zlib.deflateRawSync(inbuf, opts); |
| }, |
| |
| deflateAsync: function (/*Function*/callback) { |
| var tmp = zlib.createDeflateRaw(opts), parts = [], total = 0; |
| tmp.on('data', function (data) { |
| parts.push(data); |
| total += data.length; |
| }); |
| tmp.on('end', function () { |
| var buf = Buffer.alloc(total), written = 0; |
| buf.fill(0); |
| for (var i = 0; i < parts.length; i++) { |
| var part = parts[i]; |
| part.copy(buf, written); |
| written += part.length; |
| } |
| callback && callback(buf); |
| }); |
| tmp.end(inbuf); |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3928: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| exports.Deflater = __nccwpck_require__(7686); |
| exports.Inflater = __nccwpck_require__(2153); |
| exports.ZipCrypto = __nccwpck_require__(3228); |
| |
| /***/ }), |
| |
| /***/ 2153: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| module.exports = function (/*Buffer*/inbuf) { |
| |
| var zlib = __nccwpck_require__(8761); |
| |
| return { |
| inflate: function () { |
| return zlib.inflateRawSync(inbuf); |
| }, |
| |
| inflateAsync: function (/*Function*/callback) { |
| var tmp = zlib.createInflateRaw(), parts = [], total = 0; |
| tmp.on('data', function (data) { |
| parts.push(data); |
| total += data.length; |
| }); |
| tmp.on('end', function () { |
| var buf = Buffer.alloc(total), written = 0; |
| buf.fill(0); |
| for (var i = 0; i < parts.length; i++) { |
| var part = parts[i]; |
| part.copy(buf, written); |
| written += part.length; |
| } |
| callback && callback(buf); |
| }); |
| tmp.end(inbuf); |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3228: |
| /***/ ((module) => { |
| |
| // generate CRC32 lookup table |
| const crctable = (new Uint32Array(256)).map((t,crc)=>{ |
| for(let j=0;j<8;j++){ |
| if (0 !== (crc & 1)){ |
| crc = (crc >>> 1) ^ 0xEDB88320 |
| }else{ |
| crc >>>= 1 |
| } |
| } |
| return crc>>>0; |
| }); |
| |
| function make_decrypter(/*Buffer*/pwd){ |
| // C-style uInt32 Multiply |
| const uMul = (a,b) => Math.imul(a, b) >>> 0; |
| // Initialize keys with default values |
| const keys = new Uint32Array([0x12345678, 0x23456789, 0x34567890]); |
| // crc32 byte update |
| const crc32update = (pCrc32, bval) => { |
| return crctable[(pCrc32 ^ bval) & 0xff] ^ (pCrc32 >>> 8); |
| } |
| // update keys with byteValues |
| const updateKeys = (byteValue) => { |
| keys[0] = crc32update(keys[0], byteValue); |
| keys[1] += keys[0] & 0xff; |
| keys[1] = uMul(keys[1], 134775813) + 1; |
| keys[2] = crc32update(keys[2], keys[1] >>> 24); |
| } |
| |
| // 1. Stage initialize key |
| const pass = (Buffer.isBuffer(pwd)) ? pwd : Buffer.from(pwd); |
| for(let i=0; i< pass.length; i++){ |
| updateKeys(pass[i]); |
| } |
| |
| // return decrypter function |
| return function (/*Buffer*/data){ |
| if (!Buffer.isBuffer(data)){ |
| throw 'decrypter needs Buffer' |
| } |
| // result - we create new Buffer for results |
| const result = Buffer.alloc(data.length); |
| let pos = 0; |
| // process input data |
| for(let c of data){ |
| const k = (keys[2] | 2) >>> 0; // key |
| c ^= (uMul(k, k^1) >> 8) & 0xff; // decode |
| result[pos++] = c; // Save Value |
| updateKeys(c); // update keys with decoded byte |
| } |
| return result; |
| } |
| } |
| |
| function decrypt(/*Buffer*/ data, /*Object*/header, /*String, Buffer*/ pwd){ |
| if (!data || !Buffer.isBuffer(data) || data.length < 12) { |
| return Buffer.alloc(0); |
| } |
| |
| // We Initialize and generate decrypting function |
| const decrypter = make_decrypter(pwd); |
| |
| // check - for testing password |
| const check = header.crc >>> 24; |
| // decrypt salt what is always 12 bytes and is a part of file content |
| const testbyte = decrypter(data.slice(0, 12))[11]; |
| |
| // does password meet expectations |
| if (check !== testbyte){ |
| throw 'ADM-ZIP: Wrong Password'; |
| } |
| |
| // decode content |
| return decrypter(data.slice(12)); |
| } |
| |
| module.exports = {decrypt}; |
| |
| |
| /***/ }), |
| |
| /***/ 4522: |
| /***/ ((module) => { |
| |
| module.exports = { |
| /* The local file header */ |
| LOCHDR : 30, // LOC header size |
| LOCSIG : 0x04034b50, // "PK\003\004" |
| LOCVER : 4, // version needed to extract |
| LOCFLG : 6, // general purpose bit flag |
| LOCHOW : 8, // compression method |
| LOCTIM : 10, // modification time (2 bytes time, 2 bytes date) |
| LOCCRC : 14, // uncompressed file crc-32 value |
| LOCSIZ : 18, // compressed size |
| LOCLEN : 22, // uncompressed size |
| LOCNAM : 26, // filename length |
| LOCEXT : 28, // extra field length |
| |
| /* The Data descriptor */ |
| EXTSIG : 0x08074b50, // "PK\007\008" |
| EXTHDR : 16, // EXT header size |
| EXTCRC : 4, // uncompressed file crc-32 value |
| EXTSIZ : 8, // compressed size |
| EXTLEN : 12, // uncompressed size |
| |
| /* The central directory file header */ |
| CENHDR : 46, // CEN header size |
| CENSIG : 0x02014b50, // "PK\001\002" |
| CENVEM : 4, // version made by |
| CENVER : 6, // version needed to extract |
| CENFLG : 8, // encrypt, decrypt flags |
| CENHOW : 10, // compression method |
| CENTIM : 12, // modification time (2 bytes time, 2 bytes date) |
| CENCRC : 16, // uncompressed file crc-32 value |
| CENSIZ : 20, // compressed size |
| CENLEN : 24, // uncompressed size |
| CENNAM : 28, // filename length |
| CENEXT : 30, // extra field length |
| CENCOM : 32, // file comment length |
| CENDSK : 34, // volume number start |
| CENATT : 36, // internal file attributes |
| CENATX : 38, // external file attributes (host system dependent) |
| CENOFF : 42, // LOC header offset |
| |
| /* The entries in the end of central directory */ |
| ENDHDR : 22, // END header size |
| ENDSIG : 0x06054b50, // "PK\005\006" |
| ENDSUB : 8, // number of entries on this disk |
| ENDTOT : 10, // total number of entries |
| ENDSIZ : 12, // central directory size in bytes |
| ENDOFF : 16, // offset of first CEN header |
| ENDCOM : 20, // zip file comment length |
| |
| END64HDR : 20, // zip64 END header size |
| END64SIG : 0x07064b50, // zip64 Locator signature, "PK\006\007" |
| END64START : 4, // number of the disk with the start of the zip64 |
| END64OFF : 8, // relative offset of the zip64 end of central directory |
| END64NUMDISKS : 16, // total number of disks |
| |
| ZIP64SIG : 0x06064b50, // zip64 signature, "PK\006\006" |
| ZIP64HDR : 56, // zip64 record minimum size |
| ZIP64LEAD : 12, // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE |
| ZIP64SIZE : 4, // zip64 size of the central directory record |
| ZIP64VEM : 12, // zip64 version made by |
| ZIP64VER : 14, // zip64 version needed to extract |
| ZIP64DSK : 16, // zip64 number of this disk |
| ZIP64DSKDIR : 20, // number of the disk with the start of the record directory |
| ZIP64SUB : 24, // number of entries on this disk |
| ZIP64TOT : 32, // total number of entries |
| ZIP64SIZB : 40, // zip64 central directory size in bytes |
| ZIP64OFF : 48, // offset of start of central directory with respect to the starting disk number |
| ZIP64EXTRA : 56, // extensible data sector |
| |
| /* Compression methods */ |
| STORED : 0, // no compression |
| SHRUNK : 1, // shrunk |
| REDUCED1 : 2, // reduced with compression factor 1 |
| REDUCED2 : 3, // reduced with compression factor 2 |
| REDUCED3 : 4, // reduced with compression factor 3 |
| REDUCED4 : 5, // reduced with compression factor 4 |
| IMPLODED : 6, // imploded |
| // 7 reserved |
| DEFLATED : 8, // deflated |
| ENHANCED_DEFLATED: 9, // enhanced deflated |
| PKWARE : 10,// PKWare DCL imploded |
| // 11 reserved |
| BZIP2 : 12, // compressed using BZIP2 |
| // 13 reserved |
| LZMA : 14, // LZMA |
| // 15-17 reserved |
| IBM_TERSE : 18, // compressed using IBM TERSE |
| IBM_LZ77 : 19, //IBM LZ77 z |
| |
| /* General purpose bit flag */ |
| FLG_ENC : 0, // encripted file |
| FLG_COMP1 : 1, // compression option |
| FLG_COMP2 : 2, // compression option |
| FLG_DESC : 4, // data descriptor |
| FLG_ENH : 8, // enhanced deflation |
| FLG_STR : 16, // strong encryption |
| FLG_LNG : 1024, // language encoding |
| FLG_MSK : 4096, // mask header values |
| |
| /* Load type */ |
| FILE : 0, |
| BUFFER : 1, |
| NONE : 2, |
| |
| /* 4.5 Extensible data fields */ |
| EF_ID : 0, |
| EF_SIZE : 2, |
| |
| /* Header IDs */ |
| ID_ZIP64 : 0x0001, |
| ID_AVINFO : 0x0007, |
| ID_PFS : 0x0008, |
| ID_OS2 : 0x0009, |
| ID_NTFS : 0x000a, |
| ID_OPENVMS : 0x000c, |
| ID_UNIX : 0x000d, |
| ID_FORK : 0x000e, |
| ID_PATCH : 0x000f, |
| ID_X509_PKCS7 : 0x0014, |
| ID_X509_CERTID_F : 0x0015, |
| ID_X509_CERTID_C : 0x0016, |
| ID_STRONGENC : 0x0017, |
| ID_RECORD_MGT : 0x0018, |
| ID_X509_PKCS7_RL : 0x0019, |
| ID_IBM1 : 0x0065, |
| ID_IBM2 : 0x0066, |
| ID_POSZIP : 0x4690, |
| |
| EF_ZIP64_OR_32 : 0xffffffff, |
| EF_ZIP64_OR_16 : 0xffff, |
| EF_ZIP64_SUNCOMP : 0, |
| EF_ZIP64_SCOMP : 8, |
| EF_ZIP64_RHO : 16, |
| EF_ZIP64_DSN : 24 |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 1255: |
| /***/ ((module) => { |
| |
| module.exports = { |
| /* Header error messages */ |
| "INVALID_LOC" : "Invalid LOC header (bad signature)", |
| "INVALID_CEN" : "Invalid CEN header (bad signature)", |
| "INVALID_END" : "Invalid END header (bad signature)", |
| |
| /* ZipEntry error messages*/ |
| "NO_DATA" : "Nothing to decompress", |
| "BAD_CRC" : "CRC32 checksum failed", |
| "FILE_IN_THE_WAY" : "There is a file in the way: %s", |
| "UNKNOWN_METHOD" : "Invalid/unsupported compression method", |
| |
| /* Inflater error messages */ |
| "AVAIL_DATA" : "inflate::Available inflate data did not terminate", |
| "INVALID_DISTANCE" : "inflate::Invalid literal/length or distance code in fixed or dynamic block", |
| "TO_MANY_CODES" : "inflate::Dynamic block code description: too many length or distance codes", |
| "INVALID_REPEAT_LEN" : "inflate::Dynamic block code description: repeat more than specified lengths", |
| "INVALID_REPEAT_FIRST" : "inflate::Dynamic block code description: repeat lengths with no first length", |
| "INCOMPLETE_CODES" : "inflate::Dynamic block code description: code lengths codes incomplete", |
| "INVALID_DYN_DISTANCE": "inflate::Dynamic block code description: invalid distance code lengths", |
| "INVALID_CODES_LEN": "inflate::Dynamic block code description: invalid literal/length code lengths", |
| "INVALID_STORE_BLOCK" : "inflate::Stored block length did not match one's complement", |
| "INVALID_BLOCK_TYPE" : "inflate::Invalid block type (type == 3)", |
| |
| /* ADM-ZIP error messages */ |
| "CANT_EXTRACT_FILE" : "Could not extract the file", |
| "CANT_OVERRIDE" : "Target file already exists", |
| "NO_ZIP" : "No zip file was loaded", |
| "NO_ENTRY" : "Entry doesn't exist", |
| "DIRECTORY_CONTENT_ERROR" : "A directory cannot have content", |
| "FILE_NOT_FOUND" : "File not found: %s", |
| "NOT_IMPLEMENTED" : "Not implemented", |
| "INVALID_FILENAME" : "Invalid filename", |
| "INVALID_FORMAT" : "Invalid or unsupported zip format. No END header found" |
| }; |
| |
| /***/ }), |
| |
| /***/ 8321: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var fs = __nccwpck_require__(2895).require(), |
| pth = __nccwpck_require__(5622); |
| |
| fs.existsSync = fs.existsSync || pth.existsSync; |
| |
| module.exports = function(/*String*/path) { |
| |
| var _path = path || "", |
| _permissions = 0, |
| _obj = newAttr(), |
| _stat = null; |
| |
| function newAttr() { |
| return { |
| directory : false, |
| readonly : false, |
| hidden : false, |
| executable : false, |
| mtime : 0, |
| atime : 0 |
| } |
| } |
| |
| if (_path && fs.existsSync(_path)) { |
| _stat = fs.statSync(_path); |
| _obj.directory = _stat.isDirectory(); |
| _obj.mtime = _stat.mtime; |
| _obj.atime = _stat.atime; |
| _obj.executable = (0o111 & _stat.mode) != 0; // file is executable who ever har right not just owner |
| _obj.readonly = (0o200 & _stat.mode) == 0; // readonly if owner has no write right |
| _obj.hidden = pth.basename(_path)[0] === "."; |
| } else { |
| console.warn("Invalid path: " + _path) |
| } |
| |
| return { |
| |
| get directory () { |
| return _obj.directory; |
| }, |
| |
| get readOnly () { |
| return _obj.readonly; |
| }, |
| |
| get hidden () { |
| return _obj.hidden; |
| }, |
| |
| get mtime () { |
| return _obj.mtime; |
| }, |
| |
| get atime () { |
| return _obj.atime; |
| }, |
| |
| |
| get executable () { |
| return _obj.executable; |
| }, |
| |
| decodeAttributes : function(val) { |
| |
| }, |
| |
| encodeAttributes : function (val) { |
| |
| }, |
| |
| toString : function() { |
| return '{\n' + |
| '\t"path" : "' + _path + ",\n" + |
| '\t"isDirectory" : ' + _obj.directory + ",\n" + |
| '\t"isReadOnly" : ' + _obj.readonly + ",\n" + |
| '\t"isHidden" : ' + _obj.hidden + ",\n" + |
| '\t"isExecutable" : ' + _obj.executable + ",\n" + |
| '\t"mTime" : ' + _obj.mtime + "\n" + |
| '\t"aTime" : ' + _obj.atime + "\n" + |
| '}'; |
| } |
| } |
| |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 2895: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| exports.require = function() { |
| var fs = __nccwpck_require__(5747); |
| if (process && process.versions && process.versions['electron']) { |
| try { |
| originalFs = __nccwpck_require__(2941); |
| if (Object.keys(originalFs).length > 0) { |
| fs = originalFs; |
| } |
| } catch (e) {} |
| } |
| return fs |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 5182: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| module.exports = __nccwpck_require__(1291); |
| module.exports.FileSystem = __nccwpck_require__(2895); |
| module.exports.Constants = __nccwpck_require__(4522); |
| module.exports.Errors = __nccwpck_require__(1255); |
| module.exports.FileAttr = __nccwpck_require__(8321); |
| |
| /***/ }), |
| |
| /***/ 1291: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var fs = __nccwpck_require__(2895).require(), |
| pth = __nccwpck_require__(5622); |
| |
| fs.existsSync = fs.existsSync || pth.existsSync; |
| |
| module.exports = (function() { |
| |
| var crcTable = [], |
| Constants = __nccwpck_require__(4522), |
| Errors = __nccwpck_require__(1255), |
| |
| PATH_SEPARATOR = pth.sep; |
| |
| |
| function mkdirSync(/*String*/path) { |
| var resolvedPath = path.split(PATH_SEPARATOR)[0]; |
| path.split(PATH_SEPARATOR).forEach(function(name) { |
| if (!name || name.substr(-1,1) === ":") return; |
| resolvedPath += PATH_SEPARATOR + name; |
| var stat; |
| try { |
| stat = fs.statSync(resolvedPath); |
| } catch (e) { |
| fs.mkdirSync(resolvedPath); |
| } |
| if (stat && stat.isFile()) |
| throw Errors.FILE_IN_THE_WAY.replace("%s", resolvedPath); |
| }); |
| } |
| |
| function findSync(/*String*/dir, /*RegExp*/pattern, /*Boolean*/recoursive) { |
| if (typeof pattern === 'boolean') { |
| recoursive = pattern; |
| pattern = undefined; |
| } |
| var files = []; |
| fs.readdirSync(dir).forEach(function(file) { |
| var path = pth.join(dir, file); |
| |
| if (fs.statSync(path).isDirectory() && recoursive) |
| files = files.concat(findSync(path, pattern, recoursive)); |
| |
| if (!pattern || pattern.test(path)) { |
| files.push(pth.normalize(path) + (fs.statSync(path).isDirectory() ? PATH_SEPARATOR : "")); |
| } |
| |
| }); |
| return files; |
| } |
| |
| function readBigUInt64LE(/*Buffer*/buffer, /*int*/index) { |
| var slice = Buffer.from(buffer.slice(index, index + 8)); |
| slice.swap64(); |
| |
| return parseInt(`0x${ slice.toString('hex') }`); |
| } |
| |
| return { |
| makeDir : function(/*String*/path) { |
| mkdirSync(path); |
| }, |
| |
| crc32 : function(buf) { |
| if (typeof buf === 'string') { |
| buf = Buffer.alloc(buf.length, buf); |
| } |
| var b = Buffer.alloc(4); |
| if (!crcTable.length) { |
| for (var n = 0; n < 256; n++) { |
| var c = n; |
| for (var k = 8; --k >= 0;) // |
| if ((c & 1) !== 0) { c = 0xedb88320 ^ (c >>> 1); } else { c = c >>> 1; } |
| if (c < 0) { |
| b.writeInt32LE(c, 0); |
| c = b.readUInt32LE(0); |
| } |
| crcTable[n] = c; |
| } |
| } |
| var crc = 0, off = 0, len = buf.length, c1 = ~crc; |
| while(--len >= 0) c1 = crcTable[(c1 ^ buf[off++]) & 0xff] ^ (c1 >>> 8); |
| crc = ~c1; |
| b.writeInt32LE(crc & 0xffffffff, 0); |
| return b.readUInt32LE(0); |
| }, |
| |
| methodToString : function(/*Number*/method) { |
| switch (method) { |
| case Constants.STORED: |
| return 'STORED (' + method + ')'; |
| case Constants.DEFLATED: |
| return 'DEFLATED (' + method + ')'; |
| default: |
| return 'UNSUPPORTED (' + method + ')'; |
| } |
| |
| }, |
| |
| writeFileTo : function(/*String*/path, /*Buffer*/content, /*Boolean*/overwrite, /*Number*/attr) { |
| if (fs.existsSync(path)) { |
| if (!overwrite) |
| return false; // cannot overwrite |
| |
| var stat = fs.statSync(path); |
| if (stat.isDirectory()) { |
| return false; |
| } |
| } |
| var folder = pth.dirname(path); |
| if (!fs.existsSync(folder)) { |
| mkdirSync(folder); |
| } |
| |
| var fd; |
| try { |
| fd = fs.openSync(path, 'w', 438); // 0666 |
| } catch(e) { |
| fs.chmodSync(path, 438); |
| fd = fs.openSync(path, 'w', 438); |
| } |
| if (fd) { |
| try { |
| fs.writeSync(fd, content, 0, content.length, 0); |
| } |
| catch (e){ |
| throw e; |
| } |
| finally { |
| fs.closeSync(fd); |
| } |
| } |
| fs.chmodSync(path, attr || 438); |
| return true; |
| }, |
| |
| writeFileToAsync : function(/*String*/path, /*Buffer*/content, /*Boolean*/overwrite, /*Number*/attr, /*Function*/callback) { |
| if(typeof attr === 'function') { |
| callback = attr; |
| attr = undefined; |
| } |
| |
| fs.exists(path, function(exists) { |
| if(exists && !overwrite) |
| return callback(false); |
| |
| fs.stat(path, function(err, stat) { |
| if(exists &&stat.isDirectory()) { |
| return callback(false); |
| } |
| |
| var folder = pth.dirname(path); |
| fs.exists(folder, function(exists) { |
| if(!exists) |
| mkdirSync(folder); |
| |
| fs.open(path, 'w', 438, function(err, fd) { |
| if(err) { |
| fs.chmod(path, 438, function() { |
| fs.open(path, 'w', 438, function(err, fd) { |
| fs.write(fd, content, 0, content.length, 0, function() { |
| fs.close(fd, function() { |
| fs.chmod(path, attr || 438, function() { |
| callback(true); |
| }) |
| }); |
| }); |
| }); |
| }) |
| } else { |
| if(fd) { |
| fs.write(fd, content, 0, content.length, 0, function() { |
| fs.close(fd, function() { |
| fs.chmod(path, attr || 438, function() { |
| callback(true); |
| }) |
| }); |
| }); |
| } else { |
| fs.chmod(path, attr || 438, function() { |
| callback(true); |
| }) |
| } |
| } |
| }); |
| }) |
| }) |
| }) |
| }, |
| |
| findFiles : function(/*String*/path) { |
| return findSync(path, true); |
| }, |
| |
| getAttributes : function(/*String*/path) { |
| |
| }, |
| |
| setAttributes : function(/*String*/path) { |
| |
| }, |
| |
| toBuffer : function(input) { |
| if (Buffer.isBuffer(input)) { |
| return input; |
| } else { |
| if (input.length === 0) { |
| return Buffer.alloc(0) |
| } |
| return Buffer.from(input, 'utf8'); |
| } |
| }, |
| |
| readBigUInt64LE, |
| |
| Constants : Constants, |
| Errors : Errors |
| } |
| })(); |
| |
| |
| /***/ }), |
| |
| /***/ 4057: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var Utils = __nccwpck_require__(5182), |
| Headers = __nccwpck_require__(4958), |
| Constants = Utils.Constants, |
| Methods = __nccwpck_require__(3928); |
| |
| module.exports = function (/*Buffer*/input) { |
| |
| var _entryHeader = new Headers.EntryHeader(), |
| _entryName = Buffer.alloc(0), |
| _comment = Buffer.alloc(0), |
| _isDirectory = false, |
| uncompressedData = null, |
| _extra = Buffer.alloc(0); |
| |
| function getCompressedDataFromZip() { |
| if (!input || !Buffer.isBuffer(input)) { |
| return Buffer.alloc(0); |
| } |
| _entryHeader.loadDataHeaderFromBinary(input); |
| return input.slice(_entryHeader.realDataOffset, _entryHeader.realDataOffset + _entryHeader.compressedSize) |
| } |
| |
| function crc32OK(data) { |
| // if bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written |
| if ((_entryHeader.flags & 0x8) !== 0x8) { |
| if (Utils.crc32(data) !== _entryHeader.dataHeader.crc) { |
| return false; |
| } |
| } else { |
| // @TODO: load and check data descriptor header |
| // The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure |
| // (optionally preceded by a 4-byte signature) immediately after the compressed data: |
| } |
| return true; |
| } |
| |
| function decompress(/*Boolean*/async, /*Function*/callback, /*String, Buffer*/pass) { |
| if(typeof callback === 'undefined' && typeof async === 'string') { |
| pass=async; |
| async=void 0; |
| } |
| if (_isDirectory) { |
| if (async && callback) { |
| callback(Buffer.alloc(0), Utils.Errors.DIRECTORY_CONTENT_ERROR); //si added error. |
| } |
| return Buffer.alloc(0); |
| } |
| |
| var compressedData = getCompressedDataFromZip(); |
| |
| if (compressedData.length === 0) { |
| // File is empty, nothing to decompress. |
| if (async && callback) callback(compressedData); |
| return compressedData; |
| } |
| |
| if (_entryHeader.encripted){ |
| if ('string' !== typeof pass && !Buffer.isBuffer(pass)){ |
| throw new Error('ADM-ZIP: Incompatible password parameter'); |
| } |
| compressedData = Methods.ZipCrypto.decrypt(compressedData, _entryHeader, pass); |
| } |
| |
| var data = Buffer.alloc(_entryHeader.size); |
| |
| switch (_entryHeader.method) { |
| case Utils.Constants.STORED: |
| compressedData.copy(data); |
| if (!crc32OK(data)) { |
| if (async && callback) callback(data, Utils.Errors.BAD_CRC);//si added error |
| throw new Error(Utils.Errors.BAD_CRC); |
| } else {//si added otherwise did not seem to return data. |
| if (async && callback) callback(data); |
| return data; |
| } |
| case Utils.Constants.DEFLATED: |
| var inflater = new Methods.Inflater(compressedData); |
| if (!async) { |
| var result = inflater.inflate(data); |
| result.copy(data, 0); |
| if (!crc32OK(data)) { |
| throw new Error(Utils.Errors.BAD_CRC + " " + _entryName.toString()); |
| } |
| return data; |
| } else { |
| inflater.inflateAsync(function(result) { |
| result.copy(data, 0); |
| if (!crc32OK(data)) { |
| if (callback) callback(data, Utils.Errors.BAD_CRC); //si added error |
| } else { //si added otherwise did not seem to return data. |
| if (callback) callback(data); |
| } |
| }) |
| } |
| break; |
| default: |
| if (async && callback) callback(Buffer.alloc(0), Utils.Errors.UNKNOWN_METHOD); |
| throw new Error(Utils.Errors.UNKNOWN_METHOD); |
| } |
| } |
| |
| function compress(/*Boolean*/async, /*Function*/callback) { |
| if ((!uncompressedData || !uncompressedData.length) && Buffer.isBuffer(input)) { |
| // no data set or the data wasn't changed to require recompression |
| if (async && callback) callback(getCompressedDataFromZip()); |
| return getCompressedDataFromZip(); |
| } |
| |
| if (uncompressedData.length && !_isDirectory) { |
| var compressedData; |
| // Local file header |
| switch (_entryHeader.method) { |
| case Utils.Constants.STORED: |
| _entryHeader.compressedSize = _entryHeader.size; |
| |
| compressedData = Buffer.alloc(uncompressedData.length); |
| uncompressedData.copy(compressedData); |
| |
| if (async && callback) callback(compressedData); |
| return compressedData; |
| default: |
| case Utils.Constants.DEFLATED: |
| |
| var deflater = new Methods.Deflater(uncompressedData); |
| if (!async) { |
| var deflated = deflater.deflate(); |
| _entryHeader.compressedSize = deflated.length; |
| return deflated; |
| } else { |
| deflater.deflateAsync(function(data) { |
| compressedData = Buffer.alloc(data.length); |
| _entryHeader.compressedSize = data.length; |
| data.copy(compressedData); |
| callback && callback(compressedData); |
| }) |
| } |
| deflater = null; |
| break; |
| } |
| } else { |
| if (async && callback) { |
| callback(Buffer.alloc(0)); |
| } else { |
| return Buffer.alloc(0); |
| } |
| } |
| } |
| |
| function readUInt64LE(buffer, offset) { |
| return (buffer.readUInt32LE(offset + 4) << 4) + buffer.readUInt32LE(offset); |
| } |
| |
| function parseExtra(data) { |
| var offset = 0; |
| var signature, size, part; |
| while(offset<data.length) { |
| signature = data.readUInt16LE(offset); |
| offset += 2; |
| size = data.readUInt16LE(offset); |
| offset += 2; |
| part = data.slice(offset, offset+size); |
| offset += size; |
| if(Constants.ID_ZIP64 === signature) { |
| parseZip64ExtendedInformation(part); |
| } |
| } |
| } |
| |
| //Override header field values with values from the ZIP64 extra field |
| function parseZip64ExtendedInformation(data) { |
| var size, compressedSize, offset, diskNumStart; |
| |
| if(data.length >= Constants.EF_ZIP64_SCOMP) { |
| size = readUInt64LE(data, Constants.EF_ZIP64_SUNCOMP); |
| if(_entryHeader.size === Constants.EF_ZIP64_OR_32) { |
| _entryHeader.size = size; |
| } |
| } |
| if(data.length >= Constants.EF_ZIP64_RHO) { |
| compressedSize = readUInt64LE(data, Constants.EF_ZIP64_SCOMP); |
| if(_entryHeader.compressedSize === Constants.EF_ZIP64_OR_32) { |
| _entryHeader.compressedSize = compressedSize; |
| } |
| } |
| if(data.length >= Constants.EF_ZIP64_DSN) { |
| offset = readUInt64LE(data, Constants.EF_ZIP64_RHO); |
| if(_entryHeader.offset === Constants.EF_ZIP64_OR_32) { |
| _entryHeader.offset = offset; |
| } |
| } |
| if(data.length >= Constants.EF_ZIP64_DSN+4) { |
| diskNumStart = data.readUInt32LE(Constants.EF_ZIP64_DSN); |
| if(_entryHeader.diskNumStart === Constants.EF_ZIP64_OR_16) { |
| _entryHeader.diskNumStart = diskNumStart; |
| } |
| } |
| } |
| |
| |
| return { |
| get entryName () { return _entryName.toString(); }, |
| get rawEntryName() { return _entryName; }, |
| set entryName (val) { |
| _entryName = Utils.toBuffer(val); |
| var lastChar = _entryName[_entryName.length - 1]; |
| _isDirectory = (lastChar === 47) || (lastChar === 92); |
| _entryHeader.fileNameLength = _entryName.length; |
| }, |
| |
| get extra () { return _extra; }, |
| set extra (val) { |
| _extra = val; |
| _entryHeader.extraLength = val.length; |
| parseExtra(val); |
| }, |
| |
| get comment () { return _comment.toString(); }, |
| set comment (val) { |
| _comment = Utils.toBuffer(val); |
| _entryHeader.commentLength = _comment.length; |
| }, |
| |
| get name () { var n = _entryName.toString(); return _isDirectory ? n.substr(n.length - 1).split("/").pop() : n.split("/").pop(); }, |
| get isDirectory () { return _isDirectory }, |
| |
| getCompressedData : function() { |
| return compress(false, null) |
| }, |
| |
| getCompressedDataAsync : function(/*Function*/callback) { |
| compress(true, callback) |
| }, |
| |
| setData : function(value) { |
| uncompressedData = Utils.toBuffer(value); |
| if (!_isDirectory && uncompressedData.length) { |
| _entryHeader.size = uncompressedData.length; |
| _entryHeader.method = Utils.Constants.DEFLATED; |
| _entryHeader.crc = Utils.crc32(value); |
| _entryHeader.changed = true; |
| } else { // folders and blank files should be stored |
| _entryHeader.method = Utils.Constants.STORED; |
| } |
| }, |
| |
| getData : function(pass) { |
| if (_entryHeader.changed) { |
| return uncompressedData; |
| } else { |
| return decompress(false, null, pass); |
| } |
| }, |
| |
| getDataAsync : function(/*Function*/callback, pass) { |
| if (_entryHeader.changed) { |
| callback(uncompressedData); |
| } else { |
| decompress(true, callback, pass); |
| } |
| }, |
| |
| set attr(attr) { _entryHeader.attr = attr; }, |
| get attr() { return _entryHeader.attr; }, |
| |
| set header(/*Buffer*/data) { |
| _entryHeader.loadFromBinary(data); |
| }, |
| |
| get header() { |
| return _entryHeader; |
| }, |
| |
| packHeader : function() { |
| // 1. create header (buffer) |
| var header = _entryHeader.entryHeaderToBinary(); |
| var addpos = Utils.Constants.CENHDR; |
| // 2. add file name |
| _entryName.copy(header, addpos); |
| addpos += _entryName.length; |
| // 3. add extra data |
| if (_entryHeader.extraLength) { |
| _extra.copy(header, addpos); |
| addpos += _entryHeader.extraLength; |
| } |
| // 4. add file comment |
| if (_entryHeader.commentLength) { |
| _comment.copy(header, addpos); |
| } |
| return header; |
| }, |
| |
| toString : function() { |
| return '{\n' + |
| '\t"entryName" : "' + _entryName.toString() + "\",\n" + |
| '\t"name" : "' + (_isDirectory ? _entryName.toString().replace(/\/$/, '').split("/").pop() : _entryName.toString().split("/").pop()) + "\",\n" + |
| '\t"comment" : "' + _comment.toString() + "\",\n" + |
| '\t"isDirectory" : ' + _isDirectory + ",\n" + |
| '\t"header" : ' + _entryHeader.toString().replace(/\t/mg, "\t\t").replace(/}/mg, "\t}") + ",\n" + |
| '\t"compressedData" : <' + (input && input.length + " bytes buffer" || "null") + ">\n" + |
| '\t"data" : <' + (uncompressedData && uncompressedData.length + " bytes buffer" || "null") + ">\n" + |
| '}'; |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 7744: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var ZipEntry = __nccwpck_require__(4057), |
| Headers = __nccwpck_require__(4958), |
| Utils = __nccwpck_require__(5182); |
| |
| module.exports = function (/*String|Buffer*/input, /*Number*/inputType) { |
| var entryList = [], |
| entryTable = {}, |
| _comment = Buffer.alloc(0), |
| filename = "", |
| fs = Utils.FileSystem.require(), |
| inBuffer = null, |
| mainHeader = new Headers.MainHeader(), |
| loadedEntries = false; |
| |
| if (inputType === Utils.Constants.FILE) { |
| // is a filename |
| filename = input; |
| inBuffer = fs.readFileSync(filename); |
| readMainHeader(); |
| } else if (inputType === Utils.Constants.BUFFER) { |
| // is a memory buffer |
| inBuffer = input; |
| readMainHeader(); |
| } else { |
| // none. is a new file |
| loadedEntries = true; |
| } |
| |
| function iterateEntries(callback) { |
| const totalEntries = mainHeader.diskEntries; // total number of entries |
| let index = mainHeader.offset; // offset of first CEN header |
| |
| for (let i = 0; i < totalEntries; i++) { |
| let tmp = index; |
| const entry = new ZipEntry(inBuffer); |
| |
| entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR); |
| entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength); |
| |
| index += entry.header.entryHeaderSize; |
| |
| callback(entry); |
| } |
| } |
| |
| function readEntries() { |
| loadedEntries = true; |
| entryTable = {}; |
| entryList = new Array(mainHeader.diskEntries); // total number of entries |
| var index = mainHeader.offset; // offset of first CEN header |
| for (var i = 0; i < entryList.length; i++) { |
| |
| var tmp = index, |
| entry = new ZipEntry(inBuffer); |
| entry.header = inBuffer.slice(tmp, tmp += Utils.Constants.CENHDR); |
| |
| entry.entryName = inBuffer.slice(tmp, tmp += entry.header.fileNameLength); |
| |
| if (entry.header.extraLength) { |
| entry.extra = inBuffer.slice(tmp, tmp += entry.header.extraLength); |
| } |
| |
| if (entry.header.commentLength) |
| entry.comment = inBuffer.slice(tmp, tmp + entry.header.commentLength); |
| |
| index += entry.header.entryHeaderSize; |
| |
| entryList[i] = entry; |
| entryTable[entry.entryName] = entry; |
| } |
| } |
| |
| function readMainHeader() { |
| var i = inBuffer.length - Utils.Constants.ENDHDR, // END header size |
| max = Math.max(0, i - 0xFFFF), // 0xFFFF is the max zip file comment length |
| n = max, |
| endStart = inBuffer.length, |
| endOffset = -1, // Start offset of the END header |
| commentEnd = 0; |
| |
| for (i; i >= n; i--) { |
| if (inBuffer[i] !== 0x50) continue; // quick check that the byte is 'P' |
| if (inBuffer.readUInt32LE(i) === Utils.Constants.ENDSIG) { // "PK\005\006" |
| endOffset = i; |
| commentEnd = i; |
| endStart = i + Utils.Constants.ENDHDR; |
| // We already found a regular signature, let's look just a bit further to check if there's any zip64 signature |
| n = i - Utils.Constants.END64HDR; |
| continue; |
| } |
| |
| if (inBuffer.readUInt32LE(i) === Utils.Constants.END64SIG) { |
| // Found a zip64 signature, let's continue reading the whole zip64 record |
| n = max; |
| continue; |
| } |
| |
| if (inBuffer.readUInt32LE(i) == Utils.Constants.ZIP64SIG) { |
| // Found the zip64 record, let's determine it's size |
| endOffset = i; |
| endStart = i + Utils.readBigUInt64LE(inBuffer, i + Utils.Constants.ZIP64SIZE) + Utils.Constants.ZIP64LEAD; |
| break; |
| } |
| } |
| |
| if (!~endOffset) |
| throw new Error(Utils.Errors.INVALID_FORMAT); |
| |
| mainHeader.loadFromBinary(inBuffer.slice(endOffset, endStart)); |
| if (mainHeader.commentLength) { |
| _comment = inBuffer.slice(commentEnd + Utils.Constants.ENDHDR); |
| } |
| // readEntries(); |
| } |
| |
| return { |
| /** |
| * Returns an array of ZipEntry objects existent in the current opened archive |
| * @return Array |
| */ |
| get entries() { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| return entryList; |
| }, |
| |
| /** |
| * Archive comment |
| * @return {String} |
| */ |
| get comment() { |
| return _comment.toString(); |
| }, |
| set comment(val) { |
| _comment = Utils.toBuffer(val); |
| mainHeader.commentLength = _comment.length; |
| }, |
| |
| getEntryCount: function() { |
| if (!loadedEntries) { |
| return mainHeader.diskEntries; |
| } |
| |
| return entryList.length; |
| }, |
| |
| forEach: function(callback) { |
| if (!loadedEntries) { |
| iterateEntries(callback); |
| return; |
| } |
| |
| entryList.forEach(callback); |
| }, |
| |
| /** |
| * Returns a reference to the entry with the given name or null if entry is inexistent |
| * |
| * @param entryName |
| * @return ZipEntry |
| */ |
| getEntry: function (/*String*/entryName) { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| return entryTable[entryName] || null; |
| }, |
| |
| /** |
| * Adds the given entry to the entry list |
| * |
| * @param entry |
| */ |
| setEntry: function (/*ZipEntry*/entry) { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| entryList.push(entry); |
| entryTable[entry.entryName] = entry; |
| mainHeader.totalEntries = entryList.length; |
| }, |
| |
| /** |
| * Removes the entry with the given name from the entry list. |
| * |
| * If the entry is a directory, then all nested files and directories will be removed |
| * @param entryName |
| */ |
| deleteEntry: function (/*String*/entryName) { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| var entry = entryTable[entryName]; |
| if (entry && entry.isDirectory) { |
| var _self = this; |
| this.getEntryChildren(entry).forEach(function (child) { |
| if (child.entryName !== entryName) { |
| _self.deleteEntry(child.entryName) |
| } |
| }) |
| } |
| entryList.splice(entryList.indexOf(entry), 1); |
| delete(entryTable[entryName]); |
| mainHeader.totalEntries = entryList.length; |
| }, |
| |
| /** |
| * Iterates and returns all nested files and directories of the given entry |
| * |
| * @param entry |
| * @return Array |
| */ |
| getEntryChildren: function (/*ZipEntry*/entry) { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| if (entry.isDirectory) { |
| var list = [], |
| name = entry.entryName, |
| len = name.length; |
| |
| entryList.forEach(function (zipEntry) { |
| if (zipEntry.entryName.substr(0, len) === name) { |
| list.push(zipEntry); |
| } |
| }); |
| return list; |
| } |
| return [] |
| }, |
| |
| /** |
| * Returns the zip file |
| * |
| * @return Buffer |
| */ |
| compressToBuffer: function () { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| if (entryList.length > 1) { |
| entryList.sort(function (a, b) { |
| var nameA = a.entryName.toLowerCase(); |
| var nameB = b.entryName.toLowerCase(); |
| if (nameA < nameB) { |
| return -1 |
| } |
| if (nameA > nameB) { |
| return 1 |
| } |
| return 0; |
| }); |
| } |
| |
| var totalSize = 0, |
| dataBlock = [], |
| entryHeaders = [], |
| dindex = 0; |
| |
| mainHeader.size = 0; |
| mainHeader.offset = 0; |
| |
| entryList.forEach(function (entry) { |
| // compress data and set local and entry header accordingly. Reason why is called first |
| var compressedData = entry.getCompressedData(); |
| // data header |
| entry.header.offset = dindex; |
| var dataHeader = entry.header.dataHeaderToBinary(); |
| var entryNameLen = entry.rawEntryName.length; |
| var extra = entry.extra.toString(); |
| var postHeader = Buffer.alloc(entryNameLen + extra.length); |
| entry.rawEntryName.copy(postHeader, 0); |
| postHeader.fill(extra, entryNameLen); |
| |
| var dataLength = dataHeader.length + postHeader.length + compressedData.length; |
| |
| dindex += dataLength; |
| |
| dataBlock.push(dataHeader); |
| dataBlock.push(postHeader); |
| dataBlock.push(compressedData); |
| |
| var entryHeader = entry.packHeader(); |
| entryHeaders.push(entryHeader); |
| mainHeader.size += entryHeader.length; |
| totalSize += (dataLength + entryHeader.length); |
| }); |
| |
| totalSize += mainHeader.mainHeaderSize; // also includes zip file comment length |
| // point to end of data and beginning of central directory first record |
| mainHeader.offset = dindex; |
| |
| dindex = 0; |
| var outBuffer = Buffer.alloc(totalSize); |
| dataBlock.forEach(function (content) { |
| content.copy(outBuffer, dindex); // write data blocks |
| dindex += content.length; |
| }); |
| entryHeaders.forEach(function (content) { |
| content.copy(outBuffer, dindex); // write central directory entries |
| dindex += content.length; |
| }); |
| |
| var mh = mainHeader.toBinary(); |
| if (_comment) { |
| Buffer.from(_comment).copy(mh, Utils.Constants.ENDHDR); // add zip file comment |
| } |
| |
| mh.copy(outBuffer, dindex); // write main header |
| |
| return outBuffer |
| }, |
| |
| toAsyncBuffer: function (/*Function*/onSuccess, /*Function*/onFail, /*Function*/onItemStart, /*Function*/onItemEnd) { |
| if (!loadedEntries) { |
| readEntries(); |
| } |
| if (entryList.length > 1) { |
| entryList.sort(function (a, b) { |
| var nameA = a.entryName.toLowerCase(); |
| var nameB = b.entryName.toLowerCase(); |
| if (nameA > nameB) { |
| return -1 |
| } |
| if (nameA < nameB) { |
| return 1 |
| } |
| return 0; |
| }); |
| } |
| |
| var totalSize = 0, |
| dataBlock = [], |
| entryHeaders = [], |
| dindex = 0; |
| |
| mainHeader.size = 0; |
| mainHeader.offset = 0; |
| |
| var compress = function (entryList) { |
| var self = arguments.callee; |
| if (entryList.length) { |
| var entry = entryList.pop(); |
| var name = entry.entryName + entry.extra.toString(); |
| if (onItemStart) onItemStart(name); |
| entry.getCompressedDataAsync(function (compressedData) { |
| if (onItemEnd) onItemEnd(name); |
| |
| entry.header.offset = dindex; |
| // data header |
| var dataHeader = entry.header.dataHeaderToBinary(); |
| var postHeader; |
| try { |
| postHeader = Buffer.alloc(name.length, name); // using alloc will work on node 5.x+ |
| } catch(e){ |
| postHeader = new Buffer(name); // use deprecated method if alloc fails... |
| } |
| var dataLength = dataHeader.length + postHeader.length + compressedData.length; |
| |
| dindex += dataLength; |
| |
| dataBlock.push(dataHeader); |
| dataBlock.push(postHeader); |
| dataBlock.push(compressedData); |
| |
| var entryHeader = entry.packHeader(); |
| entryHeaders.push(entryHeader); |
| mainHeader.size += entryHeader.length; |
| totalSize += (dataLength + entryHeader.length); |
| |
| if (entryList.length) { |
| self(entryList); |
| } else { |
| |
| |
| totalSize += mainHeader.mainHeaderSize; // also includes zip file comment length |
| // point to end of data and beginning of central directory first record |
| mainHeader.offset = dindex; |
| |
| dindex = 0; |
| var outBuffer = Buffer.alloc(totalSize); |
| dataBlock.forEach(function (content) { |
| content.copy(outBuffer, dindex); // write data blocks |
| dindex += content.length; |
| }); |
| entryHeaders.forEach(function (content) { |
| content.copy(outBuffer, dindex); // write central directory entries |
| dindex += content.length; |
| }); |
| |
| var mh = mainHeader.toBinary(); |
| if (_comment) { |
| _comment.copy(mh, Utils.Constants.ENDHDR); // add zip file comment |
| } |
| |
| mh.copy(outBuffer, dindex); // write main header |
| |
| onSuccess(outBuffer); |
| } |
| }); |
| } |
| }; |
| |
| compress(entryList); |
| } |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3682: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var register = __nccwpck_require__(4670) |
| var addHook = __nccwpck_require__(5549) |
| var removeHook = __nccwpck_require__(6819) |
| |
| // bind with array of arguments: https://stackoverflow.com/a/21792913 |
| var bind = Function.bind |
| var bindable = bind.bind(bind) |
| |
| function bindApi (hook, state, name) { |
| var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]) |
| hook.api = { remove: removeHookRef } |
| hook.remove = removeHookRef |
| |
| ;['before', 'error', 'after', 'wrap'].forEach(function (kind) { |
| var args = name ? [state, kind, name] : [state, kind] |
| hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args) |
| }) |
| } |
| |
| function HookSingular () { |
| var singularHookName = 'h' |
| var singularHookState = { |
| registry: {} |
| } |
| var singularHook = register.bind(null, singularHookState, singularHookName) |
| bindApi(singularHook, singularHookState, singularHookName) |
| return singularHook |
| } |
| |
| function HookCollection () { |
| var state = { |
| registry: {} |
| } |
| |
| var hook = register.bind(null, state) |
| bindApi(hook, state) |
| |
| return hook |
| } |
| |
| var collectionHookDeprecationMessageDisplayed = false |
| function Hook () { |
| if (!collectionHookDeprecationMessageDisplayed) { |
| console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4') |
| collectionHookDeprecationMessageDisplayed = true |
| } |
| return HookCollection() |
| } |
| |
| Hook.Singular = HookSingular.bind() |
| Hook.Collection = HookCollection.bind() |
| |
| module.exports = Hook |
| // expose constructors as a named property for TypeScript |
| module.exports.Hook = Hook |
| module.exports.Singular = Hook.Singular |
| module.exports.Collection = Hook.Collection |
| |
| |
| /***/ }), |
| |
| /***/ 5549: |
| /***/ ((module) => { |
| |
| module.exports = addHook |
| |
| function addHook (state, kind, name, hook) { |
| var orig = hook |
| if (!state.registry[name]) { |
| state.registry[name] = [] |
| } |
| |
| if (kind === 'before') { |
| hook = function (method, options) { |
| return Promise.resolve() |
| .then(orig.bind(null, options)) |
| .then(method.bind(null, options)) |
| } |
| } |
| |
| if (kind === 'after') { |
| hook = function (method, options) { |
| var result |
| return Promise.resolve() |
| .then(method.bind(null, options)) |
| .then(function (result_) { |
| result = result_ |
| return orig(result, options) |
| }) |
| .then(function () { |
| return result |
| }) |
| } |
| } |
| |
| if (kind === 'error') { |
| hook = function (method, options) { |
| return Promise.resolve() |
| .then(method.bind(null, options)) |
| .catch(function (error) { |
| return orig(error, options) |
| }) |
| } |
| } |
| |
| state.registry[name].push({ |
| hook: hook, |
| orig: orig |
| }) |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 4670: |
| /***/ ((module) => { |
| |
| module.exports = register |
| |
| function register (state, name, method, options) { |
| if (typeof method !== 'function') { |
| throw new Error('method for before hook must be a function') |
| } |
| |
| if (!options) { |
| options = {} |
| } |
| |
| if (Array.isArray(name)) { |
| return name.reverse().reduce(function (callback, name) { |
| return register.bind(null, state, name, callback, options) |
| }, method)() |
| } |
| |
| return Promise.resolve() |
| .then(function () { |
| if (!state.registry[name]) { |
| return method(options) |
| } |
| |
| return (state.registry[name]).reduce(function (method, registered) { |
| return registered.hook.bind(null, method, options) |
| }, method)() |
| }) |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 6819: |
| /***/ ((module) => { |
| |
| module.exports = removeHook |
| |
| function removeHook (state, name, method) { |
| if (!state.registry[name]) { |
| return |
| } |
| |
| var index = state.registry[name] |
| .map(function (registered) { return registered.orig }) |
| .indexOf(method) |
| |
| if (index === -1) { |
| return |
| } |
| |
| state.registry[name].splice(index, 1) |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2286: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const { |
| V4MAPPED, |
| ADDRCONFIG, |
| ALL, |
| promises: { |
| Resolver: AsyncResolver |
| }, |
| lookup: dnsLookup |
| } = __nccwpck_require__(881); |
| const {promisify} = __nccwpck_require__(1669); |
| const os = __nccwpck_require__(2087); |
| |
| const kCacheableLookupCreateConnection = Symbol('cacheableLookupCreateConnection'); |
| const kCacheableLookupInstance = Symbol('cacheableLookupInstance'); |
| const kExpires = Symbol('expires'); |
| |
| const supportsALL = typeof ALL === 'number'; |
| |
| const verifyAgent = agent => { |
| if (!(agent && typeof agent.createConnection === 'function')) { |
| throw new Error('Expected an Agent instance as the first argument'); |
| } |
| }; |
| |
| const map4to6 = entries => { |
| for (const entry of entries) { |
| if (entry.family === 6) { |
| continue; |
| } |
| |
| entry.address = `::ffff:${entry.address}`; |
| entry.family = 6; |
| } |
| }; |
| |
| const getIfaceInfo = () => { |
| let has4 = false; |
| let has6 = false; |
| |
| for (const device of Object.values(os.networkInterfaces())) { |
| for (const iface of device) { |
| if (iface.internal) { |
| continue; |
| } |
| |
| if (iface.family === 'IPv6') { |
| has6 = true; |
| } else { |
| has4 = true; |
| } |
| |
| if (has4 && has6) { |
| return {has4, has6}; |
| } |
| } |
| } |
| |
| return {has4, has6}; |
| }; |
| |
| const isIterable = map => { |
| return Symbol.iterator in map; |
| }; |
| |
| const ttl = {ttl: true}; |
| const all = {all: true}; |
| |
| class CacheableLookup { |
| constructor({ |
| cache = new Map(), |
| maxTtl = Infinity, |
| fallbackDuration = 3600, |
| errorTtl = 0.15, |
| resolver = new AsyncResolver(), |
| lookup = dnsLookup |
| } = {}) { |
| this.maxTtl = maxTtl; |
| this.errorTtl = errorTtl; |
| |
| this._cache = cache; |
| this._resolver = resolver; |
| this._dnsLookup = promisify(lookup); |
| |
| if (this._resolver instanceof AsyncResolver) { |
| this._resolve4 = this._resolver.resolve4.bind(this._resolver); |
| this._resolve6 = this._resolver.resolve6.bind(this._resolver); |
| } else { |
| this._resolve4 = promisify(this._resolver.resolve4.bind(this._resolver)); |
| this._resolve6 = promisify(this._resolver.resolve6.bind(this._resolver)); |
| } |
| |
| this._iface = getIfaceInfo(); |
| |
| this._pending = {}; |
| this._nextRemovalTime = false; |
| this._hostnamesToFallback = new Set(); |
| |
| if (fallbackDuration < 1) { |
| this._fallback = false; |
| } else { |
| this._fallback = true; |
| |
| const interval = setInterval(() => { |
| this._hostnamesToFallback.clear(); |
| }, fallbackDuration * 1000); |
| |
| /* istanbul ignore next: There is no `interval.unref()` when running inside an Electron renderer */ |
| if (interval.unref) { |
| interval.unref(); |
| } |
| } |
| |
| this.lookup = this.lookup.bind(this); |
| this.lookupAsync = this.lookupAsync.bind(this); |
| } |
| |
| set servers(servers) { |
| this.clear(); |
| |
| this._resolver.setServers(servers); |
| } |
| |
| get servers() { |
| return this._resolver.getServers(); |
| } |
| |
| lookup(hostname, options, callback) { |
| if (typeof options === 'function') { |
| callback = options; |
| options = {}; |
| } else if (typeof options === 'number') { |
| options = { |
| family: options |
| }; |
| } |
| |
| if (!callback) { |
| throw new Error('Callback must be a function.'); |
| } |
| |
| // eslint-disable-next-line promise/prefer-await-to-then |
| this.lookupAsync(hostname, options).then(result => { |
| if (options.all) { |
| callback(null, result); |
| } else { |
| callback(null, result.address, result.family, result.expires, result.ttl); |
| } |
| }, callback); |
| } |
| |
| async lookupAsync(hostname, options = {}) { |
| if (typeof options === 'number') { |
| options = { |
| family: options |
| }; |
| } |
| |
| let cached = await this.query(hostname); |
| |
| if (options.family === 6) { |
| const filtered = cached.filter(entry => entry.family === 6); |
| |
| if (options.hints & V4MAPPED) { |
| if ((supportsALL && options.hints & ALL) || filtered.length === 0) { |
| map4to6(cached); |
| } else { |
| cached = filtered; |
| } |
| } else { |
| cached = filtered; |
| } |
| } else if (options.family === 4) { |
| cached = cached.filter(entry => entry.family === 4); |
| } |
| |
| if (options.hints & ADDRCONFIG) { |
| const {_iface} = this; |
| cached = cached.filter(entry => entry.family === 6 ? _iface.has6 : _iface.has4); |
| } |
| |
| if (cached.length === 0) { |
| const error = new Error(`cacheableLookup ENOTFOUND ${hostname}`); |
| error.code = 'ENOTFOUND'; |
| error.hostname = hostname; |
| |
| throw error; |
| } |
| |
| if (options.all) { |
| return cached; |
| } |
| |
| return cached[0]; |
| } |
| |
| async query(hostname) { |
| let cached = await this._cache.get(hostname); |
| |
| if (!cached) { |
| const pending = this._pending[hostname]; |
| |
| if (pending) { |
| cached = await pending; |
| } else { |
| const newPromise = this.queryAndCache(hostname); |
| this._pending[hostname] = newPromise; |
| |
| try { |
| cached = await newPromise; |
| } finally { |
| delete this._pending[hostname]; |
| } |
| } |
| } |
| |
| cached = cached.map(entry => { |
| return {...entry}; |
| }); |
| |
| return cached; |
| } |
| |
| async _resolve(hostname) { |
| const wrap = async promise => { |
| try { |
| return await promise; |
| } catch (error) { |
| if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') { |
| return []; |
| } |
| |
| throw error; |
| } |
| }; |
| |
| // ANY is unsafe as it doesn't trigger new queries in the underlying server. |
| const [A, AAAA] = await Promise.all([ |
| this._resolve4(hostname, ttl), |
| this._resolve6(hostname, ttl) |
| ].map(promise => wrap(promise))); |
| |
| let aTtl = 0; |
| let aaaaTtl = 0; |
| let cacheTtl = 0; |
| |
| const now = Date.now(); |
| |
| for (const entry of A) { |
| entry.family = 4; |
| entry.expires = now + (entry.ttl * 1000); |
| |
| aTtl = Math.max(aTtl, entry.ttl); |
| } |
| |
| for (const entry of AAAA) { |
| entry.family = 6; |
| entry.expires = now + (entry.ttl * 1000); |
| |
| aaaaTtl = Math.max(aaaaTtl, entry.ttl); |
| } |
| |
| if (A.length > 0) { |
| if (AAAA.length > 0) { |
| cacheTtl = Math.min(aTtl, aaaaTtl); |
| } else { |
| cacheTtl = aTtl; |
| } |
| } else { |
| cacheTtl = aaaaTtl; |
| } |
| |
| return { |
| entries: [ |
| ...A, |
| ...AAAA |
| ], |
| cacheTtl |
| }; |
| } |
| |
| async _lookup(hostname) { |
| try { |
| const entries = await this._dnsLookup(hostname, { |
| all: true |
| }); |
| |
| return { |
| entries, |
| cacheTtl: 0 |
| }; |
| } catch (_) { |
| return { |
| entries: [], |
| cacheTtl: 0 |
| }; |
| } |
| } |
| |
| async _set(hostname, data, cacheTtl) { |
| if (this.maxTtl > 0 && cacheTtl > 0) { |
| cacheTtl = Math.min(cacheTtl, this.maxTtl) * 1000; |
| data[kExpires] = Date.now() + cacheTtl; |
| |
| try { |
| await this._cache.set(hostname, data, cacheTtl); |
| } catch (error) { |
| this.lookupAsync = async () => { |
| const cacheError = new Error('Cache Error. Please recreate the CacheableLookup instance.'); |
| cacheError.cause = error; |
| |
| throw cacheError; |
| }; |
| } |
| |
| if (isIterable(this._cache)) { |
| this._tick(cacheTtl); |
| } |
| } |
| } |
| |
| async queryAndCache(hostname) { |
| if (this._hostnamesToFallback.has(hostname)) { |
| return this._dnsLookup(hostname, all); |
| } |
| |
| let query = await this._resolve(hostname); |
| |
| if (query.entries.length === 0 && this._fallback) { |
| query = await this._lookup(hostname); |
| |
| if (query.entries.length !== 0) { |
| // Use `dns.lookup(...)` for that particular hostname |
| this._hostnamesToFallback.add(hostname); |
| } |
| } |
| |
| const cacheTtl = query.entries.length === 0 ? this.errorTtl : query.cacheTtl; |
| await this._set(hostname, query.entries, cacheTtl); |
| |
| return query.entries; |
| } |
| |
| _tick(ms) { |
| const nextRemovalTime = this._nextRemovalTime; |
| |
| if (!nextRemovalTime || ms < nextRemovalTime) { |
| clearTimeout(this._removalTimeout); |
| |
| this._nextRemovalTime = ms; |
| |
| this._removalTimeout = setTimeout(() => { |
| this._nextRemovalTime = false; |
| |
| let nextExpiry = Infinity; |
| |
| const now = Date.now(); |
| |
| for (const [hostname, entries] of this._cache) { |
| const expires = entries[kExpires]; |
| |
| if (now >= expires) { |
| this._cache.delete(hostname); |
| } else if (expires < nextExpiry) { |
| nextExpiry = expires; |
| } |
| } |
| |
| if (nextExpiry !== Infinity) { |
| this._tick(nextExpiry - now); |
| } |
| }, ms); |
| |
| /* istanbul ignore next: There is no `timeout.unref()` when running inside an Electron renderer */ |
| if (this._removalTimeout.unref) { |
| this._removalTimeout.unref(); |
| } |
| } |
| } |
| |
| install(agent) { |
| verifyAgent(agent); |
| |
| if (kCacheableLookupCreateConnection in agent) { |
| throw new Error('CacheableLookup has been already installed'); |
| } |
| |
| agent[kCacheableLookupCreateConnection] = agent.createConnection; |
| agent[kCacheableLookupInstance] = this; |
| |
| agent.createConnection = (options, callback) => { |
| if (!('lookup' in options)) { |
| options.lookup = this.lookup; |
| } |
| |
| return agent[kCacheableLookupCreateConnection](options, callback); |
| }; |
| } |
| |
| uninstall(agent) { |
| verifyAgent(agent); |
| |
| if (agent[kCacheableLookupCreateConnection]) { |
| if (agent[kCacheableLookupInstance] !== this) { |
| throw new Error('The agent is not owned by this CacheableLookup instance'); |
| } |
| |
| agent.createConnection = agent[kCacheableLookupCreateConnection]; |
| |
| delete agent[kCacheableLookupCreateConnection]; |
| delete agent[kCacheableLookupInstance]; |
| } |
| } |
| |
| updateInterfaceInfo() { |
| const {_iface} = this; |
| |
| this._iface = getIfaceInfo(); |
| |
| if ((_iface.has4 && !this._iface.has4) || (_iface.has6 && !this._iface.has6)) { |
| this._cache.clear(); |
| } |
| } |
| |
| clear(hostname) { |
| if (hostname) { |
| this._cache.delete(hostname); |
| return; |
| } |
| |
| this._cache.clear(); |
| } |
| } |
| |
| module.exports = CacheableLookup; |
| module.exports.default = CacheableLookup; |
| |
| |
| /***/ }), |
| |
| /***/ 4340: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const {PassThrough: PassThroughStream} = __nccwpck_require__(2413); |
| |
| module.exports = options => { |
| options = {...options}; |
| |
| const {array} = options; |
| let {encoding} = options; |
| const isBuffer = encoding === 'buffer'; |
| let objectMode = false; |
| |
| if (array) { |
| objectMode = !(encoding || isBuffer); |
| } else { |
| encoding = encoding || 'utf8'; |
| } |
| |
| if (isBuffer) { |
| encoding = null; |
| } |
| |
| const stream = new PassThroughStream({objectMode}); |
| |
| if (encoding) { |
| stream.setEncoding(encoding); |
| } |
| |
| let length = 0; |
| const chunks = []; |
| |
| stream.on('data', chunk => { |
| chunks.push(chunk); |
| |
| if (objectMode) { |
| length = chunks.length; |
| } else { |
| length += chunk.length; |
| } |
| }); |
| |
| stream.getBufferedValue = () => { |
| if (array) { |
| return chunks; |
| } |
| |
| return isBuffer ? Buffer.concat(chunks, length) : chunks.join(''); |
| }; |
| |
| stream.getBufferedLength = () => length; |
| |
| return stream; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 7040: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const {constants: BufferConstants} = __nccwpck_require__(4293); |
| const pump = __nccwpck_require__(8341); |
| const bufferStream = __nccwpck_require__(4340); |
| |
| class MaxBufferError extends Error { |
| constructor() { |
| super('maxBuffer exceeded'); |
| this.name = 'MaxBufferError'; |
| } |
| } |
| |
| async function getStream(inputStream, options) { |
| if (!inputStream) { |
| return Promise.reject(new Error('Expected a stream')); |
| } |
| |
| options = { |
| maxBuffer: Infinity, |
| ...options |
| }; |
| |
| const {maxBuffer} = options; |
| |
| let stream; |
| await new Promise((resolve, reject) => { |
| const rejectPromise = error => { |
| // Don't retrieve an oversized buffer. |
| if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) { |
| error.bufferedData = stream.getBufferedValue(); |
| } |
| |
| reject(error); |
| }; |
| |
| stream = pump(inputStream, bufferStream(options), error => { |
| if (error) { |
| rejectPromise(error); |
| return; |
| } |
| |
| resolve(); |
| }); |
| |
| stream.on('data', () => { |
| if (stream.getBufferedLength() > maxBuffer) { |
| rejectPromise(new MaxBufferError()); |
| } |
| }); |
| }); |
| |
| return stream.getBufferedValue(); |
| } |
| |
| module.exports = getStream; |
| // TODO: Remove this for the next major release |
| module.exports.default = getStream; |
| module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'}); |
| module.exports.array = (stream, options) => getStream(stream, {...options, array: true}); |
| module.exports.MaxBufferError = MaxBufferError; |
| |
| |
| /***/ }), |
| |
| /***/ 8116: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const EventEmitter = __nccwpck_require__(8614); |
| const urlLib = __nccwpck_require__(8835); |
| const normalizeUrl = __nccwpck_require__(7952); |
| const getStream = __nccwpck_require__(7040); |
| const CachePolicy = __nccwpck_require__(1002); |
| const Response = __nccwpck_require__(9004); |
| const lowercaseKeys = __nccwpck_require__(9662); |
| const cloneResponse = __nccwpck_require__(1312); |
| const Keyv = __nccwpck_require__(1531); |
| |
| class CacheableRequest { |
| constructor(request, cacheAdapter) { |
| if (typeof request !== 'function') { |
| throw new TypeError('Parameter `request` must be a function'); |
| } |
| |
| this.cache = new Keyv({ |
| uri: typeof cacheAdapter === 'string' && cacheAdapter, |
| store: typeof cacheAdapter !== 'string' && cacheAdapter, |
| namespace: 'cacheable-request' |
| }); |
| |
| return this.createCacheableRequest(request); |
| } |
| |
| createCacheableRequest(request) { |
| return (opts, cb) => { |
| let url; |
| if (typeof opts === 'string') { |
| url = normalizeUrlObject(urlLib.parse(opts)); |
| opts = {}; |
| } else if (opts instanceof urlLib.URL) { |
| url = normalizeUrlObject(urlLib.parse(opts.toString())); |
| opts = {}; |
| } else { |
| const [pathname, ...searchParts] = (opts.path || '').split('?'); |
| const search = searchParts.length > 0 ? |
| `?${searchParts.join('?')}` : |
| ''; |
| url = normalizeUrlObject({ ...opts, pathname, search }); |
| } |
| |
| opts = { |
| headers: {}, |
| method: 'GET', |
| cache: true, |
| strictTtl: false, |
| automaticFailover: false, |
| ...opts, |
| ...urlObjectToRequestOptions(url) |
| }; |
| opts.headers = lowercaseKeys(opts.headers); |
| |
| const ee = new EventEmitter(); |
| const normalizedUrlString = normalizeUrl( |
| urlLib.format(url), |
| { |
| stripWWW: false, |
| removeTrailingSlash: false, |
| stripAuthentication: false |
| } |
| ); |
| const key = `${opts.method}:${normalizedUrlString}`; |
| let revalidate = false; |
| let madeRequest = false; |
| |
| const makeRequest = opts => { |
| madeRequest = true; |
| let requestErrored = false; |
| let requestErrorCallback; |
| |
| const requestErrorPromise = new Promise(resolve => { |
| requestErrorCallback = () => { |
| if (!requestErrored) { |
| requestErrored = true; |
| resolve(); |
| } |
| }; |
| }); |
| |
| const handler = response => { |
| if (revalidate && !opts.forceRefresh) { |
| response.status = response.statusCode; |
| const revalidatedPolicy = CachePolicy.fromObject(revalidate.cachePolicy).revalidatedPolicy(opts, response); |
| if (!revalidatedPolicy.modified) { |
| const headers = revalidatedPolicy.policy.responseHeaders(); |
| response = new Response(revalidate.statusCode, headers, revalidate.body, revalidate.url); |
| response.cachePolicy = revalidatedPolicy.policy; |
| response.fromCache = true; |
| } |
| } |
| |
| if (!response.fromCache) { |
| response.cachePolicy = new CachePolicy(opts, response, opts); |
| response.fromCache = false; |
| } |
| |
| let clonedResponse; |
| if (opts.cache && response.cachePolicy.storable()) { |
| clonedResponse = cloneResponse(response); |
| |
| (async () => { |
| try { |
| const bodyPromise = getStream.buffer(response); |
| |
| await Promise.race([ |
| requestErrorPromise, |
| new Promise(resolve => response.once('end', resolve)) |
| ]); |
| |
| if (requestErrored) { |
| return; |
| } |
| |
| const body = await bodyPromise; |
| |
| const value = { |
| cachePolicy: response.cachePolicy.toObject(), |
| url: response.url, |
| statusCode: response.fromCache ? revalidate.statusCode : response.statusCode, |
| body |
| }; |
| |
| let ttl = opts.strictTtl ? response.cachePolicy.timeToLive() : undefined; |
| if (opts.maxTtl) { |
| ttl = ttl ? Math.min(ttl, opts.maxTtl) : opts.maxTtl; |
| } |
| |
| await this.cache.set(key, value, ttl); |
| } catch (error) { |
| ee.emit('error', new CacheableRequest.CacheError(error)); |
| } |
| })(); |
| } else if (opts.cache && revalidate) { |
| (async () => { |
| try { |
| await this.cache.delete(key); |
| } catch (error) { |
| ee.emit('error', new CacheableRequest.CacheError(error)); |
| } |
| })(); |
| } |
| |
| ee.emit('response', clonedResponse || response); |
| if (typeof cb === 'function') { |
| cb(clonedResponse || response); |
| } |
| }; |
| |
| try { |
| const req = request(opts, handler); |
| req.once('error', requestErrorCallback); |
| req.once('abort', requestErrorCallback); |
| ee.emit('request', req); |
| } catch (error) { |
| ee.emit('error', new CacheableRequest.RequestError(error)); |
| } |
| }; |
| |
| (async () => { |
| const get = async opts => { |
| await Promise.resolve(); |
| |
| const cacheEntry = opts.cache ? await this.cache.get(key) : undefined; |
| if (typeof cacheEntry === 'undefined') { |
| return makeRequest(opts); |
| } |
| |
| const policy = CachePolicy.fromObject(cacheEntry.cachePolicy); |
| if (policy.satisfiesWithoutRevalidation(opts) && !opts.forceRefresh) { |
| const headers = policy.responseHeaders(); |
| const response = new Response(cacheEntry.statusCode, headers, cacheEntry.body, cacheEntry.url); |
| response.cachePolicy = policy; |
| response.fromCache = true; |
| |
| ee.emit('response', response); |
| if (typeof cb === 'function') { |
| cb(response); |
| } |
| } else { |
| revalidate = cacheEntry; |
| opts.headers = policy.revalidationHeaders(opts); |
| makeRequest(opts); |
| } |
| }; |
| |
| const errorHandler = error => ee.emit('error', new CacheableRequest.CacheError(error)); |
| this.cache.once('error', errorHandler); |
| ee.on('response', () => this.cache.removeListener('error', errorHandler)); |
| |
| try { |
| await get(opts); |
| } catch (error) { |
| if (opts.automaticFailover && !madeRequest) { |
| makeRequest(opts); |
| } |
| |
| ee.emit('error', new CacheableRequest.CacheError(error)); |
| } |
| })(); |
| |
| return ee; |
| }; |
| } |
| } |
| |
| function urlObjectToRequestOptions(url) { |
| const options = { ...url }; |
| options.path = `${url.pathname || '/'}${url.search || ''}`; |
| delete options.pathname; |
| delete options.search; |
| return options; |
| } |
| |
| function normalizeUrlObject(url) { |
| // If url was parsed by url.parse or new URL: |
| // - hostname will be set |
| // - host will be hostname[:port] |
| // - port will be set if it was explicit in the parsed string |
| // Otherwise, url was from request options: |
| // - hostname or host may be set |
| // - host shall not have port encoded |
| return { |
| protocol: url.protocol, |
| auth: url.auth, |
| hostname: url.hostname || url.host || 'localhost', |
| port: url.port, |
| pathname: url.pathname, |
| search: url.search |
| }; |
| } |
| |
| CacheableRequest.RequestError = class extends Error { |
| constructor(error) { |
| super(error.message); |
| this.name = 'RequestError'; |
| Object.assign(this, error); |
| } |
| }; |
| |
| CacheableRequest.CacheError = class extends Error { |
| constructor(error) { |
| super(error.message); |
| this.name = 'CacheError'; |
| Object.assign(this, error); |
| } |
| }; |
| |
| module.exports = CacheableRequest; |
| |
| |
| /***/ }), |
| |
| /***/ 1312: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const PassThrough = __nccwpck_require__(2413).PassThrough; |
| const mimicResponse = __nccwpck_require__(2610); |
| |
| const cloneResponse = response => { |
| if (!(response && response.pipe)) { |
| throw new TypeError('Parameter `response` must be a response stream.'); |
| } |
| |
| const clone = new PassThrough(); |
| mimicResponse(response, clone); |
| |
| return response.pipe(clone); |
| }; |
| |
| module.exports = cloneResponse; |
| |
| |
| /***/ }), |
| |
| /***/ 2391: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const {Transform, PassThrough} = __nccwpck_require__(2413); |
| const zlib = __nccwpck_require__(8761); |
| const mimicResponse = __nccwpck_require__(3877); |
| |
| module.exports = response => { |
| const contentEncoding = (response.headers['content-encoding'] || '').toLowerCase(); |
| |
| if (!['gzip', 'deflate', 'br'].includes(contentEncoding)) { |
| return response; |
| } |
| |
| // TODO: Remove this when targeting Node.js 12. |
| const isBrotli = contentEncoding === 'br'; |
| if (isBrotli && typeof zlib.createBrotliDecompress !== 'function') { |
| response.destroy(new Error('Brotli is not supported on Node.js < 12')); |
| return response; |
| } |
| |
| let isEmpty = true; |
| |
| const checker = new Transform({ |
| transform(data, _encoding, callback) { |
| isEmpty = false; |
| |
| callback(null, data); |
| }, |
| |
| flush(callback) { |
| callback(); |
| } |
| }); |
| |
| const finalStream = new PassThrough({ |
| autoDestroy: false, |
| destroy(error, callback) { |
| response.destroy(); |
| |
| callback(error); |
| } |
| }); |
| |
| const decompressStream = isBrotli ? zlib.createBrotliDecompress() : zlib.createUnzip(); |
| |
| decompressStream.once('error', error => { |
| if (isEmpty && !response.readable) { |
| finalStream.end(); |
| return; |
| } |
| |
| finalStream.destroy(error); |
| }); |
| |
| mimicResponse(response, finalStream); |
| response.pipe(checker).pipe(decompressStream).pipe(finalStream); |
| |
| return finalStream; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3877: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| // We define these manually to ensure they're always copied |
| // even if they would move up the prototype chain |
| // https://nodejs.org/api/http.html#http_class_http_incomingmessage |
| const knownProperties = [ |
| 'aborted', |
| 'complete', |
| 'headers', |
| 'httpVersion', |
| 'httpVersionMinor', |
| 'httpVersionMajor', |
| 'method', |
| 'rawHeaders', |
| 'rawTrailers', |
| 'setTimeout', |
| 'socket', |
| 'statusCode', |
| 'statusMessage', |
| 'trailers', |
| 'url' |
| ]; |
| |
| module.exports = (fromStream, toStream) => { |
| if (toStream._readableState.autoDestroy) { |
| throw new Error('The second stream must have the `autoDestroy` option set to `false`'); |
| } |
| |
| const fromProperties = new Set(Object.keys(fromStream).concat(knownProperties)); |
| |
| const properties = {}; |
| |
| for (const property of fromProperties) { |
| // Don't overwrite existing properties. |
| if (property in toStream) { |
| continue; |
| } |
| |
| properties[property] = { |
| get() { |
| const value = fromStream[property]; |
| const isFunction = typeof value === 'function'; |
| |
| return isFunction ? value.bind(fromStream) : value; |
| }, |
| set(value) { |
| fromStream[property] = value; |
| }, |
| enumerable: true, |
| configurable: false |
| }; |
| } |
| |
| Object.defineProperties(toStream, properties); |
| |
| fromStream.once('aborted', () => { |
| toStream.destroy(); |
| |
| toStream.emit('aborted'); |
| }); |
| |
| fromStream.once('close', () => { |
| if (fromStream.complete) { |
| if (toStream.readable) { |
| toStream.once('end', () => { |
| toStream.emit('close'); |
| }); |
| } else { |
| toStream.emit('close'); |
| } |
| } else { |
| toStream.emit('close'); |
| } |
| }); |
| |
| return toStream; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 6214: |
| /***/ ((module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| function isTLSSocket(socket) { |
| return socket.encrypted; |
| } |
| const deferToConnect = (socket, fn) => { |
| let listeners; |
| if (typeof fn === 'function') { |
| const connect = fn; |
| listeners = { connect }; |
| } |
| else { |
| listeners = fn; |
| } |
| const hasConnectListener = typeof listeners.connect === 'function'; |
| const hasSecureConnectListener = typeof listeners.secureConnect === 'function'; |
| const hasCloseListener = typeof listeners.close === 'function'; |
| const onConnect = () => { |
| if (hasConnectListener) { |
| listeners.connect(); |
| } |
| if (isTLSSocket(socket) && hasSecureConnectListener) { |
| if (socket.authorized) { |
| listeners.secureConnect(); |
| } |
| else if (!socket.authorizationError) { |
| socket.once('secureConnect', listeners.secureConnect); |
| } |
| } |
| if (hasCloseListener) { |
| socket.once('close', listeners.close); |
| } |
| }; |
| if (socket.writable && !socket.connecting) { |
| onConnect(); |
| } |
| else if (socket.connecting) { |
| socket.once('connect', onConnect); |
| } |
| else if (socket.destroyed && hasCloseListener) { |
| listeners.close(socket._hadError); |
| } |
| }; |
| exports.default = deferToConnect; |
| // For CommonJS default export support |
| module.exports = deferToConnect; |
| module.exports.default = deferToConnect; |
| |
| |
| /***/ }), |
| |
| /***/ 8932: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| class Deprecation extends Error { |
| constructor(message) { |
| super(message); // Maintains proper stack trace (only available on V8) |
| |
| /* istanbul ignore next */ |
| |
| if (Error.captureStackTrace) { |
| Error.captureStackTrace(this, this.constructor); |
| } |
| |
| this.name = 'Deprecation'; |
| } |
| |
| } |
| |
| exports.Deprecation = Deprecation; |
| |
| |
| /***/ }), |
| |
| /***/ 1205: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var once = __nccwpck_require__(1223); |
| |
| var noop = function() {}; |
| |
| var isRequest = function(stream) { |
| return stream.setHeader && typeof stream.abort === 'function'; |
| }; |
| |
| var isChildProcess = function(stream) { |
| return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3 |
| }; |
| |
| var eos = function(stream, opts, callback) { |
| if (typeof opts === 'function') return eos(stream, null, opts); |
| if (!opts) opts = {}; |
| |
| callback = once(callback || noop); |
| |
| var ws = stream._writableState; |
| var rs = stream._readableState; |
| var readable = opts.readable || (opts.readable !== false && stream.readable); |
| var writable = opts.writable || (opts.writable !== false && stream.writable); |
| var cancelled = false; |
| |
| var onlegacyfinish = function() { |
| if (!stream.writable) onfinish(); |
| }; |
| |
| var onfinish = function() { |
| writable = false; |
| if (!readable) callback.call(stream); |
| }; |
| |
| var onend = function() { |
| readable = false; |
| if (!writable) callback.call(stream); |
| }; |
| |
| var onexit = function(exitCode) { |
| callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null); |
| }; |
| |
| var onerror = function(err) { |
| callback.call(stream, err); |
| }; |
| |
| var onclose = function() { |
| process.nextTick(onclosenexttick); |
| }; |
| |
| var onclosenexttick = function() { |
| if (cancelled) return; |
| if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close')); |
| if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close')); |
| }; |
| |
| var onrequest = function() { |
| stream.req.on('finish', onfinish); |
| }; |
| |
| if (isRequest(stream)) { |
| stream.on('complete', onfinish); |
| stream.on('abort', onclose); |
| if (stream.req) onrequest(); |
| else stream.on('request', onrequest); |
| } else if (writable && !ws) { // legacy streams |
| stream.on('end', onlegacyfinish); |
| stream.on('close', onlegacyfinish); |
| } |
| |
| if (isChildProcess(stream)) stream.on('exit', onexit); |
| |
| stream.on('end', onend); |
| stream.on('finish', onfinish); |
| if (opts.error !== false) stream.on('error', onerror); |
| stream.on('close', onclose); |
| |
| return function() { |
| cancelled = true; |
| stream.removeListener('complete', onfinish); |
| stream.removeListener('abort', onclose); |
| stream.removeListener('request', onrequest); |
| if (stream.req) stream.req.removeListener('finish', onfinish); |
| stream.removeListener('end', onlegacyfinish); |
| stream.removeListener('close', onlegacyfinish); |
| stream.removeListener('finish', onfinish); |
| stream.removeListener('exit', onexit); |
| stream.removeListener('end', onend); |
| stream.removeListener('error', onerror); |
| stream.removeListener('close', onclose); |
| }; |
| }; |
| |
| module.exports = eos; |
| |
| |
| /***/ }), |
| |
| /***/ 5582: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const stringify = __nccwpck_require__(4810); |
| const compile = __nccwpck_require__(7123); |
| const expand = __nccwpck_require__(6944); |
| const parse = __nccwpck_require__(9889); |
| |
| /** |
| * Expand the given pattern or create a regex-compatible string. |
| * |
| * ```js |
| * const braces = require('braces'); |
| * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)'] |
| * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c'] |
| * ``` |
| * @param {String} `str` |
| * @param {Object} `options` |
| * @return {String} |
| * @api public |
| */ |
| |
| const braces = (input, options = {}) => { |
| let output = []; |
| |
| if (Array.isArray(input)) { |
| for (let pattern of input) { |
| let result = braces.create(pattern, options); |
| if (Array.isArray(result)) { |
| output.push(...result); |
| } else { |
| output.push(result); |
| } |
| } |
| } else { |
| output = [].concat(braces.create(input, options)); |
| } |
| |
| if (options && options.expand === true && options.nodupes === true) { |
| output = [...new Set(output)]; |
| } |
| return output; |
| }; |
| |
| /** |
| * Parse the given `str` with the given `options`. |
| * |
| * ```js |
| * // braces.parse(pattern, [, options]); |
| * const ast = braces.parse('a/{b,c}/d'); |
| * console.log(ast); |
| * ``` |
| * @param {String} pattern Brace pattern to parse |
| * @param {Object} options |
| * @return {Object} Returns an AST |
| * @api public |
| */ |
| |
| braces.parse = (input, options = {}) => parse(input, options); |
| |
| /** |
| * Creates a braces string from an AST, or an AST node. |
| * |
| * ```js |
| * const braces = require('braces'); |
| * let ast = braces.parse('foo/{a,b}/bar'); |
| * console.log(stringify(ast.nodes[2])); //=> '{a,b}' |
| * ``` |
| * @param {String} `input` Brace pattern or AST. |
| * @param {Object} `options` |
| * @return {Array} Returns an array of expanded values. |
| * @api public |
| */ |
| |
| braces.stringify = (input, options = {}) => { |
| if (typeof input === 'string') { |
| return stringify(braces.parse(input, options), options); |
| } |
| return stringify(input, options); |
| }; |
| |
| /** |
| * Compiles a brace pattern into a regex-compatible, optimized string. |
| * This method is called by the main [braces](#braces) function by default. |
| * |
| * ```js |
| * const braces = require('braces'); |
| * console.log(braces.compile('a/{b,c}/d')); |
| * //=> ['a/(b|c)/d'] |
| * ``` |
| * @param {String} `input` Brace pattern or AST. |
| * @param {Object} `options` |
| * @return {Array} Returns an array of expanded values. |
| * @api public |
| */ |
| |
| braces.compile = (input, options = {}) => { |
| if (typeof input === 'string') { |
| input = braces.parse(input, options); |
| } |
| return compile(input, options); |
| }; |
| |
| /** |
| * Expands a brace pattern into an array. This method is called by the |
| * main [braces](#braces) function when `options.expand` is true. Before |
| * using this method it's recommended that you read the [performance notes](#performance)) |
| * and advantages of using [.compile](#compile) instead. |
| * |
| * ```js |
| * const braces = require('braces'); |
| * console.log(braces.expand('a/{b,c}/d')); |
| * //=> ['a/b/d', 'a/c/d']; |
| * ``` |
| * @param {String} `pattern` Brace pattern |
| * @param {Object} `options` |
| * @return {Array} Returns an array of expanded values. |
| * @api public |
| */ |
| |
| braces.expand = (input, options = {}) => { |
| if (typeof input === 'string') { |
| input = braces.parse(input, options); |
| } |
| |
| let result = expand(input, options); |
| |
| // filter out empty strings if specified |
| if (options.noempty === true) { |
| result = result.filter(Boolean); |
| } |
| |
| // filter out duplicates if specified |
| if (options.nodupes === true) { |
| result = [...new Set(result)]; |
| } |
| |
| return result; |
| }; |
| |
| /** |
| * Processes a brace pattern and returns either an expanded array |
| * (if `options.expand` is true), a highly optimized regex-compatible string. |
| * This method is called by the main [braces](#braces) function. |
| * |
| * ```js |
| * const braces = require('braces'); |
| * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}')) |
| * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)' |
| * ``` |
| * @param {String} `pattern` Brace pattern |
| * @param {Object} `options` |
| * @return {Array} Returns an array of expanded values. |
| * @api public |
| */ |
| |
| braces.create = (input, options = {}) => { |
| if (input === '' || input.length < 3) { |
| return [input]; |
| } |
| |
| return options.expand !== true |
| ? braces.compile(input, options) |
| : braces.expand(input, options); |
| }; |
| |
| /** |
| * Expose "braces" |
| */ |
| |
| module.exports = braces; |
| |
| |
| /***/ }), |
| |
| /***/ 7123: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const fill = __nccwpck_require__(791); |
| const utils = __nccwpck_require__(7691); |
| |
| const compile = (ast, options = {}) => { |
| let walk = (node, parent = {}) => { |
| let invalidBlock = utils.isInvalidBrace(parent); |
| let invalidNode = node.invalid === true && options.escapeInvalid === true; |
| let invalid = invalidBlock === true || invalidNode === true; |
| let prefix = options.escapeInvalid === true ? '\\' : ''; |
| let output = ''; |
| |
| if (node.isOpen === true) { |
| return prefix + node.value; |
| } |
| if (node.isClose === true) { |
| return prefix + node.value; |
| } |
| |
| if (node.type === 'open') { |
| return invalid ? (prefix + node.value) : '('; |
| } |
| |
| if (node.type === 'close') { |
| return invalid ? (prefix + node.value) : ')'; |
| } |
| |
| if (node.type === 'comma') { |
| return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|'); |
| } |
| |
| if (node.value) { |
| return node.value; |
| } |
| |
| if (node.nodes && node.ranges > 0) { |
| let args = utils.reduce(node.nodes); |
| let range = fill(...args, { ...options, wrap: false, toRegex: true }); |
| |
| if (range.length !== 0) { |
| return args.length > 1 && range.length > 1 ? `(${range})` : range; |
| } |
| } |
| |
| if (node.nodes) { |
| for (let child of node.nodes) { |
| output += walk(child, node); |
| } |
| } |
| return output; |
| }; |
| |
| return walk(ast); |
| }; |
| |
| module.exports = compile; |
| |
| |
| /***/ }), |
| |
| /***/ 5412: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| module.exports = { |
| MAX_LENGTH: 1024 * 64, |
| |
| // Digits |
| CHAR_0: '0', /* 0 */ |
| CHAR_9: '9', /* 9 */ |
| |
| // Alphabet chars. |
| CHAR_UPPERCASE_A: 'A', /* A */ |
| CHAR_LOWERCASE_A: 'a', /* a */ |
| CHAR_UPPERCASE_Z: 'Z', /* Z */ |
| CHAR_LOWERCASE_Z: 'z', /* z */ |
| |
| CHAR_LEFT_PARENTHESES: '(', /* ( */ |
| CHAR_RIGHT_PARENTHESES: ')', /* ) */ |
| |
| CHAR_ASTERISK: '*', /* * */ |
| |
| // Non-alphabetic chars. |
| CHAR_AMPERSAND: '&', /* & */ |
| CHAR_AT: '@', /* @ */ |
| CHAR_BACKSLASH: '\\', /* \ */ |
| CHAR_BACKTICK: '`', /* ` */ |
| CHAR_CARRIAGE_RETURN: '\r', /* \r */ |
| CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */ |
| CHAR_COLON: ':', /* : */ |
| CHAR_COMMA: ',', /* , */ |
| CHAR_DOLLAR: '$', /* . */ |
| CHAR_DOT: '.', /* . */ |
| CHAR_DOUBLE_QUOTE: '"', /* " */ |
| CHAR_EQUAL: '=', /* = */ |
| CHAR_EXCLAMATION_MARK: '!', /* ! */ |
| CHAR_FORM_FEED: '\f', /* \f */ |
| CHAR_FORWARD_SLASH: '/', /* / */ |
| CHAR_HASH: '#', /* # */ |
| CHAR_HYPHEN_MINUS: '-', /* - */ |
| CHAR_LEFT_ANGLE_BRACKET: '<', /* < */ |
| CHAR_LEFT_CURLY_BRACE: '{', /* { */ |
| CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */ |
| CHAR_LINE_FEED: '\n', /* \n */ |
| CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */ |
| CHAR_PERCENT: '%', /* % */ |
| CHAR_PLUS: '+', /* + */ |
| CHAR_QUESTION_MARK: '?', /* ? */ |
| CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */ |
| CHAR_RIGHT_CURLY_BRACE: '}', /* } */ |
| CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */ |
| CHAR_SEMICOLON: ';', /* ; */ |
| CHAR_SINGLE_QUOTE: '\'', /* ' */ |
| CHAR_SPACE: ' ', /* */ |
| CHAR_TAB: '\t', /* \t */ |
| CHAR_UNDERSCORE: '_', /* _ */ |
| CHAR_VERTICAL_LINE: '|', /* | */ |
| CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */ |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 6944: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const fill = __nccwpck_require__(791); |
| const stringify = __nccwpck_require__(4810); |
| const utils = __nccwpck_require__(7691); |
| |
| const append = (queue = '', stash = '', enclose = false) => { |
| let result = []; |
| |
| queue = [].concat(queue); |
| stash = [].concat(stash); |
| |
| if (!stash.length) return queue; |
| if (!queue.length) { |
| return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash; |
| } |
| |
| for (let item of queue) { |
| if (Array.isArray(item)) { |
| for (let value of item) { |
| result.push(append(value, stash, enclose)); |
| } |
| } else { |
| for (let ele of stash) { |
| if (enclose === true && typeof ele === 'string') ele = `{${ele}}`; |
| result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele)); |
| } |
| } |
| } |
| return utils.flatten(result); |
| }; |
| |
| const expand = (ast, options = {}) => { |
| let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit; |
| |
| let walk = (node, parent = {}) => { |
| node.queue = []; |
| |
| let p = parent; |
| let q = parent.queue; |
| |
| while (p.type !== 'brace' && p.type !== 'root' && p.parent) { |
| p = p.parent; |
| q = p.queue; |
| } |
| |
| if (node.invalid || node.dollar) { |
| q.push(append(q.pop(), stringify(node, options))); |
| return; |
| } |
| |
| if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) { |
| q.push(append(q.pop(), ['{}'])); |
| return; |
| } |
| |
| if (node.nodes && node.ranges > 0) { |
| let args = utils.reduce(node.nodes); |
| |
| if (utils.exceedsLimit(...args, options.step, rangeLimit)) { |
| throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.'); |
| } |
| |
| let range = fill(...args, options); |
| if (range.length === 0) { |
| range = stringify(node, options); |
| } |
| |
| q.push(append(q.pop(), range)); |
| node.nodes = []; |
| return; |
| } |
| |
| let enclose = utils.encloseBrace(node); |
| let queue = node.queue; |
| let block = node; |
| |
| while (block.type !== 'brace' && block.type !== 'root' && block.parent) { |
| block = block.parent; |
| queue = block.queue; |
| } |
| |
| for (let i = 0; i < node.nodes.length; i++) { |
| let child = node.nodes[i]; |
| |
| if (child.type === 'comma' && node.type === 'brace') { |
| if (i === 1) queue.push(''); |
| queue.push(''); |
| continue; |
| } |
| |
| if (child.type === 'close') { |
| q.push(append(q.pop(), queue, enclose)); |
| continue; |
| } |
| |
| if (child.value && child.type !== 'open') { |
| queue.push(append(queue.pop(), child.value)); |
| continue; |
| } |
| |
| if (child.nodes) { |
| walk(child, node); |
| } |
| } |
| |
| return queue; |
| }; |
| |
| return utils.flatten(walk(ast)); |
| }; |
| |
| module.exports = expand; |
| |
| |
| /***/ }), |
| |
| /***/ 9889: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const stringify = __nccwpck_require__(4810); |
| |
| /** |
| * Constants |
| */ |
| |
| const { |
| MAX_LENGTH, |
| CHAR_BACKSLASH, /* \ */ |
| CHAR_BACKTICK, /* ` */ |
| CHAR_COMMA, /* , */ |
| CHAR_DOT, /* . */ |
| CHAR_LEFT_PARENTHESES, /* ( */ |
| CHAR_RIGHT_PARENTHESES, /* ) */ |
| CHAR_LEFT_CURLY_BRACE, /* { */ |
| CHAR_RIGHT_CURLY_BRACE, /* } */ |
| CHAR_LEFT_SQUARE_BRACKET, /* [ */ |
| CHAR_RIGHT_SQUARE_BRACKET, /* ] */ |
| CHAR_DOUBLE_QUOTE, /* " */ |
| CHAR_SINGLE_QUOTE, /* ' */ |
| CHAR_NO_BREAK_SPACE, |
| CHAR_ZERO_WIDTH_NOBREAK_SPACE |
| } = __nccwpck_require__(5412); |
| |
| /** |
| * parse |
| */ |
| |
| const parse = (input, options = {}) => { |
| if (typeof input !== 'string') { |
| throw new TypeError('Expected a string'); |
| } |
| |
| let opts = options || {}; |
| let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; |
| if (input.length > max) { |
| throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`); |
| } |
| |
| let ast = { type: 'root', input, nodes: [] }; |
| let stack = [ast]; |
| let block = ast; |
| let prev = ast; |
| let brackets = 0; |
| let length = input.length; |
| let index = 0; |
| let depth = 0; |
| let value; |
| let memo = {}; |
| |
| /** |
| * Helpers |
| */ |
| |
| const advance = () => input[index++]; |
| const push = node => { |
| if (node.type === 'text' && prev.type === 'dot') { |
| prev.type = 'text'; |
| } |
| |
| if (prev && prev.type === 'text' && node.type === 'text') { |
| prev.value += node.value; |
| return; |
| } |
| |
| block.nodes.push(node); |
| node.parent = block; |
| node.prev = prev; |
| prev = node; |
| return node; |
| }; |
| |
| push({ type: 'bos' }); |
| |
| while (index < length) { |
| block = stack[stack.length - 1]; |
| value = advance(); |
| |
| /** |
| * Invalid chars |
| */ |
| |
| if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) { |
| continue; |
| } |
| |
| /** |
| * Escaped chars |
| */ |
| |
| if (value === CHAR_BACKSLASH) { |
| push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() }); |
| continue; |
| } |
| |
| /** |
| * Right square bracket (literal): ']' |
| */ |
| |
| if (value === CHAR_RIGHT_SQUARE_BRACKET) { |
| push({ type: 'text', value: '\\' + value }); |
| continue; |
| } |
| |
| /** |
| * Left square bracket: '[' |
| */ |
| |
| if (value === CHAR_LEFT_SQUARE_BRACKET) { |
| brackets++; |
| |
| let closed = true; |
| let next; |
| |
| while (index < length && (next = advance())) { |
| value += next; |
| |
| if (next === CHAR_LEFT_SQUARE_BRACKET) { |
| brackets++; |
| continue; |
| } |
| |
| if (next === CHAR_BACKSLASH) { |
| value += advance(); |
| continue; |
| } |
| |
| if (next === CHAR_RIGHT_SQUARE_BRACKET) { |
| brackets--; |
| |
| if (brackets === 0) { |
| break; |
| } |
| } |
| } |
| |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| /** |
| * Parentheses |
| */ |
| |
| if (value === CHAR_LEFT_PARENTHESES) { |
| block = push({ type: 'paren', nodes: [] }); |
| stack.push(block); |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| if (value === CHAR_RIGHT_PARENTHESES) { |
| if (block.type !== 'paren') { |
| push({ type: 'text', value }); |
| continue; |
| } |
| block = stack.pop(); |
| push({ type: 'text', value }); |
| block = stack[stack.length - 1]; |
| continue; |
| } |
| |
| /** |
| * Quotes: '|"|` |
| */ |
| |
| if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) { |
| let open = value; |
| let next; |
| |
| if (options.keepQuotes !== true) { |
| value = ''; |
| } |
| |
| while (index < length && (next = advance())) { |
| if (next === CHAR_BACKSLASH) { |
| value += next + advance(); |
| continue; |
| } |
| |
| if (next === open) { |
| if (options.keepQuotes === true) value += next; |
| break; |
| } |
| |
| value += next; |
| } |
| |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| /** |
| * Left curly brace: '{' |
| */ |
| |
| if (value === CHAR_LEFT_CURLY_BRACE) { |
| depth++; |
| |
| let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true; |
| let brace = { |
| type: 'brace', |
| open: true, |
| close: false, |
| dollar, |
| depth, |
| commas: 0, |
| ranges: 0, |
| nodes: [] |
| }; |
| |
| block = push(brace); |
| stack.push(block); |
| push({ type: 'open', value }); |
| continue; |
| } |
| |
| /** |
| * Right curly brace: '}' |
| */ |
| |
| if (value === CHAR_RIGHT_CURLY_BRACE) { |
| if (block.type !== 'brace') { |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| let type = 'close'; |
| block = stack.pop(); |
| block.close = true; |
| |
| push({ type, value }); |
| depth--; |
| |
| block = stack[stack.length - 1]; |
| continue; |
| } |
| |
| /** |
| * Comma: ',' |
| */ |
| |
| if (value === CHAR_COMMA && depth > 0) { |
| if (block.ranges > 0) { |
| block.ranges = 0; |
| let open = block.nodes.shift(); |
| block.nodes = [open, { type: 'text', value: stringify(block) }]; |
| } |
| |
| push({ type: 'comma', value }); |
| block.commas++; |
| continue; |
| } |
| |
| /** |
| * Dot: '.' |
| */ |
| |
| if (value === CHAR_DOT && depth > 0 && block.commas === 0) { |
| let siblings = block.nodes; |
| |
| if (depth === 0 || siblings.length === 0) { |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| if (prev.type === 'dot') { |
| block.range = []; |
| prev.value += value; |
| prev.type = 'range'; |
| |
| if (block.nodes.length !== 3 && block.nodes.length !== 5) { |
| block.invalid = true; |
| block.ranges = 0; |
| prev.type = 'text'; |
| continue; |
| } |
| |
| block.ranges++; |
| block.args = []; |
| continue; |
| } |
| |
| if (prev.type === 'range') { |
| siblings.pop(); |
| |
| let before = siblings[siblings.length - 1]; |
| before.value += prev.value + value; |
| prev = before; |
| block.ranges--; |
| continue; |
| } |
| |
| push({ type: 'dot', value }); |
| continue; |
| } |
| |
| /** |
| * Text |
| */ |
| |
| push({ type: 'text', value }); |
| } |
| |
| // Mark imbalanced braces and brackets as invalid |
| do { |
| block = stack.pop(); |
| |
| if (block.type !== 'root') { |
| block.nodes.forEach(node => { |
| if (!node.nodes) { |
| if (node.type === 'open') node.isOpen = true; |
| if (node.type === 'close') node.isClose = true; |
| if (!node.nodes) node.type = 'text'; |
| node.invalid = true; |
| } |
| }); |
| |
| // get the location of the block on parent.nodes (block's siblings) |
| let parent = stack[stack.length - 1]; |
| let index = parent.nodes.indexOf(block); |
| // replace the (invalid) block with it's nodes |
| parent.nodes.splice(index, 1, ...block.nodes); |
| } |
| } while (stack.length > 0); |
| |
| push({ type: 'eos' }); |
| return ast; |
| }; |
| |
| module.exports = parse; |
| |
| |
| /***/ }), |
| |
| /***/ 4810: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const utils = __nccwpck_require__(7691); |
| |
| module.exports = (ast, options = {}) => { |
| let stringify = (node, parent = {}) => { |
| let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent); |
| let invalidNode = node.invalid === true && options.escapeInvalid === true; |
| let output = ''; |
| |
| if (node.value) { |
| if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) { |
| return '\\' + node.value; |
| } |
| return node.value; |
| } |
| |
| if (node.value) { |
| return node.value; |
| } |
| |
| if (node.nodes) { |
| for (let child of node.nodes) { |
| output += stringify(child); |
| } |
| } |
| return output; |
| }; |
| |
| return stringify(ast); |
| }; |
| |
| |
| |
| /***/ }), |
| |
| /***/ 7691: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| exports.isInteger = num => { |
| if (typeof num === 'number') { |
| return Number.isInteger(num); |
| } |
| if (typeof num === 'string' && num.trim() !== '') { |
| return Number.isInteger(Number(num)); |
| } |
| return false; |
| }; |
| |
| /** |
| * Find a node of the given type |
| */ |
| |
| exports.find = (node, type) => node.nodes.find(node => node.type === type); |
| |
| /** |
| * Find a node of the given type |
| */ |
| |
| exports.exceedsLimit = (min, max, step = 1, limit) => { |
| if (limit === false) return false; |
| if (!exports.isInteger(min) || !exports.isInteger(max)) return false; |
| return ((Number(max) - Number(min)) / Number(step)) >= limit; |
| }; |
| |
| /** |
| * Escape the given node with '\\' before node.value |
| */ |
| |
| exports.escapeNode = (block, n = 0, type) => { |
| let node = block.nodes[n]; |
| if (!node) return; |
| |
| if ((type && node.type === type) || node.type === 'open' || node.type === 'close') { |
| if (node.escaped !== true) { |
| node.value = '\\' + node.value; |
| node.escaped = true; |
| } |
| } |
| }; |
| |
| /** |
| * Returns true if the given brace node should be enclosed in literal braces |
| */ |
| |
| exports.encloseBrace = node => { |
| if (node.type !== 'brace') return false; |
| if ((node.commas >> 0 + node.ranges >> 0) === 0) { |
| node.invalid = true; |
| return true; |
| } |
| return false; |
| }; |
| |
| /** |
| * Returns true if a brace node is invalid. |
| */ |
| |
| exports.isInvalidBrace = block => { |
| if (block.type !== 'brace') return false; |
| if (block.invalid === true || block.dollar) return true; |
| if ((block.commas >> 0 + block.ranges >> 0) === 0) { |
| block.invalid = true; |
| return true; |
| } |
| if (block.open !== true || block.close !== true) { |
| block.invalid = true; |
| return true; |
| } |
| return false; |
| }; |
| |
| /** |
| * Returns true if a node is an open or close node |
| */ |
| |
| exports.isOpenOrClose = node => { |
| if (node.type === 'open' || node.type === 'close') { |
| return true; |
| } |
| return node.open === true || node.close === true; |
| }; |
| |
| /** |
| * Reduce an array of text nodes. |
| */ |
| |
| exports.reduce = nodes => nodes.reduce((acc, node) => { |
| if (node.type === 'text') acc.push(node.value); |
| if (node.type === 'range') node.type = 'text'; |
| return acc; |
| }, []); |
| |
| /** |
| * Flatten an array |
| */ |
| |
| exports.flatten = (...args) => { |
| const result = []; |
| const flat = arr => { |
| for (let i = 0; i < arr.length; i++) { |
| let ele = arr[i]; |
| Array.isArray(ele) ? flat(ele, result) : ele !== void 0 && result.push(ele); |
| } |
| return result; |
| }; |
| flat(args); |
| return result; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 791: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| /*! |
| * fill-range <https://github.com/jonschlinkert/fill-range> |
| * |
| * Copyright (c) 2014-present, Jon Schlinkert. |
| * Licensed under the MIT License. |
| */ |
| |
| |
| |
| const util = __nccwpck_require__(1669); |
| const toRegexRange = __nccwpck_require__(6867); |
| |
| const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); |
| |
| const transform = toNumber => { |
| return value => toNumber === true ? Number(value) : String(value); |
| }; |
| |
| const isValidValue = value => { |
| return typeof value === 'number' || (typeof value === 'string' && value !== ''); |
| }; |
| |
| const isNumber = num => Number.isInteger(+num); |
| |
| const zeros = input => { |
| let value = `${input}`; |
| let index = -1; |
| if (value[0] === '-') value = value.slice(1); |
| if (value === '0') return false; |
| while (value[++index] === '0'); |
| return index > 0; |
| }; |
| |
| const stringify = (start, end, options) => { |
| if (typeof start === 'string' || typeof end === 'string') { |
| return true; |
| } |
| return options.stringify === true; |
| }; |
| |
| const pad = (input, maxLength, toNumber) => { |
| if (maxLength > 0) { |
| let dash = input[0] === '-' ? '-' : ''; |
| if (dash) input = input.slice(1); |
| input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0')); |
| } |
| if (toNumber === false) { |
| return String(input); |
| } |
| return input; |
| }; |
| |
| const toMaxLen = (input, maxLength) => { |
| let negative = input[0] === '-' ? '-' : ''; |
| if (negative) { |
| input = input.slice(1); |
| maxLength--; |
| } |
| while (input.length < maxLength) input = '0' + input; |
| return negative ? ('-' + input) : input; |
| }; |
| |
| const toSequence = (parts, options) => { |
| parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); |
| parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); |
| |
| let prefix = options.capture ? '' : '?:'; |
| let positives = ''; |
| let negatives = ''; |
| let result; |
| |
| if (parts.positives.length) { |
| positives = parts.positives.join('|'); |
| } |
| |
| if (parts.negatives.length) { |
| negatives = `-(${prefix}${parts.negatives.join('|')})`; |
| } |
| |
| if (positives && negatives) { |
| result = `${positives}|${negatives}`; |
| } else { |
| result = positives || negatives; |
| } |
| |
| if (options.wrap) { |
| return `(${prefix}${result})`; |
| } |
| |
| return result; |
| }; |
| |
| const toRange = (a, b, isNumbers, options) => { |
| if (isNumbers) { |
| return toRegexRange(a, b, { wrap: false, ...options }); |
| } |
| |
| let start = String.fromCharCode(a); |
| if (a === b) return start; |
| |
| let stop = String.fromCharCode(b); |
| return `[${start}-${stop}]`; |
| }; |
| |
| const toRegex = (start, end, options) => { |
| if (Array.isArray(start)) { |
| let wrap = options.wrap === true; |
| let prefix = options.capture ? '' : '?:'; |
| return wrap ? `(${prefix}${start.join('|')})` : start.join('|'); |
| } |
| return toRegexRange(start, end, options); |
| }; |
| |
| const rangeError = (...args) => { |
| return new RangeError('Invalid range arguments: ' + util.inspect(...args)); |
| }; |
| |
| const invalidRange = (start, end, options) => { |
| if (options.strictRanges === true) throw rangeError([start, end]); |
| return []; |
| }; |
| |
| const invalidStep = (step, options) => { |
| if (options.strictRanges === true) { |
| throw new TypeError(`Expected step "${step}" to be a number`); |
| } |
| return []; |
| }; |
| |
| const fillNumbers = (start, end, step = 1, options = {}) => { |
| let a = Number(start); |
| let b = Number(end); |
| |
| if (!Number.isInteger(a) || !Number.isInteger(b)) { |
| if (options.strictRanges === true) throw rangeError([start, end]); |
| return []; |
| } |
| |
| // fix negative zero |
| if (a === 0) a = 0; |
| if (b === 0) b = 0; |
| |
| let descending = a > b; |
| let startString = String(start); |
| let endString = String(end); |
| let stepString = String(step); |
| step = Math.max(Math.abs(step), 1); |
| |
| let padded = zeros(startString) || zeros(endString) || zeros(stepString); |
| let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0; |
| let toNumber = padded === false && stringify(start, end, options) === false; |
| let format = options.transform || transform(toNumber); |
| |
| if (options.toRegex && step === 1) { |
| return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options); |
| } |
| |
| let parts = { negatives: [], positives: [] }; |
| let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)); |
| let range = []; |
| let index = 0; |
| |
| while (descending ? a >= b : a <= b) { |
| if (options.toRegex === true && step > 1) { |
| push(a); |
| } else { |
| range.push(pad(format(a, index), maxLen, toNumber)); |
| } |
| a = descending ? a - step : a + step; |
| index++; |
| } |
| |
| if (options.toRegex === true) { |
| return step > 1 |
| ? toSequence(parts, options) |
| : toRegex(range, null, { wrap: false, ...options }); |
| } |
| |
| return range; |
| }; |
| |
| const fillLetters = (start, end, step = 1, options = {}) => { |
| if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) { |
| return invalidRange(start, end, options); |
| } |
| |
| |
| let format = options.transform || (val => String.fromCharCode(val)); |
| let a = `${start}`.charCodeAt(0); |
| let b = `${end}`.charCodeAt(0); |
| |
| let descending = a > b; |
| let min = Math.min(a, b); |
| let max = Math.max(a, b); |
| |
| if (options.toRegex && step === 1) { |
| return toRange(min, max, false, options); |
| } |
| |
| let range = []; |
| let index = 0; |
| |
| while (descending ? a >= b : a <= b) { |
| range.push(format(a, index)); |
| a = descending ? a - step : a + step; |
| index++; |
| } |
| |
| if (options.toRegex === true) { |
| return toRegex(range, null, { wrap: false, options }); |
| } |
| |
| return range; |
| }; |
| |
| const fill = (start, end, step, options = {}) => { |
| if (end == null && isValidValue(start)) { |
| return [start]; |
| } |
| |
| if (!isValidValue(start) || !isValidValue(end)) { |
| return invalidRange(start, end, options); |
| } |
| |
| if (typeof step === 'function') { |
| return fill(start, end, 1, { transform: step }); |
| } |
| |
| if (isObject(step)) { |
| return fill(start, end, 0, step); |
| } |
| |
| let opts = { ...options }; |
| if (opts.capture === true) opts.wrap = true; |
| step = step || opts.step || 1; |
| |
| if (!isNumber(step)) { |
| if (step != null && !isObject(step)) return invalidStep(step, opts); |
| return fill(start, end, 1, step); |
| } |
| |
| if (isNumber(start) && isNumber(end)) { |
| return fillNumbers(start, end, step, opts); |
| } |
| |
| return fillLetters(start, end, Math.max(Math.abs(step), 1), opts); |
| }; |
| |
| module.exports = fill; |
| |
| |
| /***/ }), |
| |
| /***/ 2840: |
| /***/ ((module) => { |
| |
| "use strict"; |
| /*! |
| * is-number <https://github.com/jonschlinkert/is-number> |
| * |
| * Copyright (c) 2014-present, Jon Schlinkert. |
| * Released under the MIT License. |
| */ |
| |
| |
| |
| module.exports = function(num) { |
| if (typeof num === 'number') { |
| return num - num === 0; |
| } |
| if (typeof num === 'string' && num.trim() !== '') { |
| return Number.isFinite ? Number.isFinite(+num) : isFinite(+num); |
| } |
| return false; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3913: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const util = __nccwpck_require__(1669); |
| const braces = __nccwpck_require__(5582); |
| const picomatch = __nccwpck_require__(8569); |
| const utils = __nccwpck_require__(479); |
| const isEmptyString = val => typeof val === 'string' && (val === '' || val === './'); |
| |
| /** |
| * Returns an array of strings that match one or more glob patterns. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm(list, patterns[, options]); |
| * |
| * console.log(mm(['a.js', 'a.txt'], ['*.js'])); |
| * //=> [ 'a.js' ] |
| * ``` |
| * @param {String|Array<string>} list List of strings to match. |
| * @param {String|Array<string>} patterns One or more glob patterns to use for matching. |
| * @param {Object} options See available [options](#options) |
| * @return {Array} Returns an array of matches |
| * @summary false |
| * @api public |
| */ |
| |
| const micromatch = (list, patterns, options) => { |
| patterns = [].concat(patterns); |
| list = [].concat(list); |
| |
| let omit = new Set(); |
| let keep = new Set(); |
| let items = new Set(); |
| let negatives = 0; |
| |
| let onResult = state => { |
| items.add(state.output); |
| if (options && options.onResult) { |
| options.onResult(state); |
| } |
| }; |
| |
| for (let i = 0; i < patterns.length; i++) { |
| let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true); |
| let negated = isMatch.state.negated || isMatch.state.negatedExtglob; |
| if (negated) negatives++; |
| |
| for (let item of list) { |
| let matched = isMatch(item, true); |
| |
| let match = negated ? !matched.isMatch : matched.isMatch; |
| if (!match) continue; |
| |
| if (negated) { |
| omit.add(matched.output); |
| } else { |
| omit.delete(matched.output); |
| keep.add(matched.output); |
| } |
| } |
| } |
| |
| let result = negatives === patterns.length ? [...items] : [...keep]; |
| let matches = result.filter(item => !omit.has(item)); |
| |
| if (options && matches.length === 0) { |
| if (options.failglob === true) { |
| throw new Error(`No matches found for "${patterns.join(', ')}"`); |
| } |
| |
| if (options.nonull === true || options.nullglob === true) { |
| return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns; |
| } |
| } |
| |
| return matches; |
| }; |
| |
| /** |
| * Backwards compatibility |
| */ |
| |
| micromatch.match = micromatch; |
| |
| /** |
| * Returns a matcher function from the given glob `pattern` and `options`. |
| * The returned function takes a string to match as its only argument and returns |
| * true if the string is a match. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.matcher(pattern[, options]); |
| * |
| * const isMatch = mm.matcher('*.!(*a)'); |
| * console.log(isMatch('a.a')); //=> false |
| * console.log(isMatch('a.b')); //=> true |
| * ``` |
| * @param {String} `pattern` Glob pattern |
| * @param {Object} `options` |
| * @return {Function} Returns a matcher function. |
| * @api public |
| */ |
| |
| micromatch.matcher = (pattern, options) => picomatch(pattern, options); |
| |
| /** |
| * Returns true if **any** of the given glob `patterns` match the specified `string`. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.isMatch(string, patterns[, options]); |
| * |
| * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true |
| * console.log(mm.isMatch('a.a', 'b.*')); //=> false |
| * ``` |
| * @param {String} str The string to test. |
| * @param {String|Array} patterns One or more glob patterns to use for matching. |
| * @param {Object} [options] See available [options](#options). |
| * @return {Boolean} Returns true if any patterns match `str` |
| * @api public |
| */ |
| |
| micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); |
| |
| /** |
| * Backwards compatibility |
| */ |
| |
| micromatch.any = micromatch.isMatch; |
| |
| /** |
| * Returns a list of strings that _**do not match any**_ of the given `patterns`. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.not(list, patterns[, options]); |
| * |
| * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a')); |
| * //=> ['b.b', 'c.c'] |
| * ``` |
| * @param {Array} `list` Array of strings to match. |
| * @param {String|Array} `patterns` One or more glob pattern to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Array} Returns an array of strings that **do not match** the given patterns. |
| * @api public |
| */ |
| |
| micromatch.not = (list, patterns, options = {}) => { |
| patterns = [].concat(patterns).map(String); |
| let result = new Set(); |
| let items = []; |
| |
| let onResult = state => { |
| if (options.onResult) options.onResult(state); |
| items.push(state.output); |
| }; |
| |
| let matches = micromatch(list, patterns, { ...options, onResult }); |
| |
| for (let item of items) { |
| if (!matches.includes(item)) { |
| result.add(item); |
| } |
| } |
| return [...result]; |
| }; |
| |
| /** |
| * Returns true if the given `string` contains the given pattern. Similar |
| * to [.isMatch](#isMatch) but the pattern can match any part of the string. |
| * |
| * ```js |
| * var mm = require('micromatch'); |
| * // mm.contains(string, pattern[, options]); |
| * |
| * console.log(mm.contains('aa/bb/cc', '*b')); |
| * //=> true |
| * console.log(mm.contains('aa/bb/cc', '*d')); |
| * //=> false |
| * ``` |
| * @param {String} `str` The string to match. |
| * @param {String|Array} `patterns` Glob pattern to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Boolean} Returns true if the patter matches any part of `str`. |
| * @api public |
| */ |
| |
| micromatch.contains = (str, pattern, options) => { |
| if (typeof str !== 'string') { |
| throw new TypeError(`Expected a string: "${util.inspect(str)}"`); |
| } |
| |
| if (Array.isArray(pattern)) { |
| return pattern.some(p => micromatch.contains(str, p, options)); |
| } |
| |
| if (typeof pattern === 'string') { |
| if (isEmptyString(str) || isEmptyString(pattern)) { |
| return false; |
| } |
| |
| if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) { |
| return true; |
| } |
| } |
| |
| return micromatch.isMatch(str, pattern, { ...options, contains: true }); |
| }; |
| |
| /** |
| * Filter the keys of the given object with the given `glob` pattern |
| * and `options`. Does not attempt to match nested keys. If you need this feature, |
| * use [glob-object][] instead. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.matchKeys(object, patterns[, options]); |
| * |
| * const obj = { aa: 'a', ab: 'b', ac: 'c' }; |
| * console.log(mm.matchKeys(obj, '*b')); |
| * //=> { ab: 'b' } |
| * ``` |
| * @param {Object} `object` The object with keys to filter. |
| * @param {String|Array} `patterns` One or more glob patterns to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Object} Returns an object with only keys that match the given patterns. |
| * @api public |
| */ |
| |
| micromatch.matchKeys = (obj, patterns, options) => { |
| if (!utils.isObject(obj)) { |
| throw new TypeError('Expected the first argument to be an object'); |
| } |
| let keys = micromatch(Object.keys(obj), patterns, options); |
| let res = {}; |
| for (let key of keys) res[key] = obj[key]; |
| return res; |
| }; |
| |
| /** |
| * Returns true if some of the strings in the given `list` match any of the given glob `patterns`. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.some(list, patterns[, options]); |
| * |
| * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); |
| * // true |
| * console.log(mm.some(['foo.js'], ['*.js', '!foo.js'])); |
| * // false |
| * ``` |
| * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found. |
| * @param {String|Array} `patterns` One or more glob patterns to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Boolean} Returns true if any patterns match `str` |
| * @api public |
| */ |
| |
| micromatch.some = (list, patterns, options) => { |
| let items = [].concat(list); |
| |
| for (let pattern of [].concat(patterns)) { |
| let isMatch = picomatch(String(pattern), options); |
| if (items.some(item => isMatch(item))) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| /** |
| * Returns true if every string in the given `list` matches |
| * any of the given glob `patterns`. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.every(list, patterns[, options]); |
| * |
| * console.log(mm.every('foo.js', ['foo.js'])); |
| * // true |
| * console.log(mm.every(['foo.js', 'bar.js'], ['*.js'])); |
| * // true |
| * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js'])); |
| * // false |
| * console.log(mm.every(['foo.js'], ['*.js', '!foo.js'])); |
| * // false |
| * ``` |
| * @param {String|Array} `list` The string or array of strings to test. |
| * @param {String|Array} `patterns` One or more glob patterns to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Boolean} Returns true if any patterns match `str` |
| * @api public |
| */ |
| |
| micromatch.every = (list, patterns, options) => { |
| let items = [].concat(list); |
| |
| for (let pattern of [].concat(patterns)) { |
| let isMatch = picomatch(String(pattern), options); |
| if (!items.every(item => isMatch(item))) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| /** |
| * Returns true if **all** of the given `patterns` match |
| * the specified string. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.all(string, patterns[, options]); |
| * |
| * console.log(mm.all('foo.js', ['foo.js'])); |
| * // true |
| * |
| * console.log(mm.all('foo.js', ['*.js', '!foo.js'])); |
| * // false |
| * |
| * console.log(mm.all('foo.js', ['*.js', 'foo.js'])); |
| * // true |
| * |
| * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js'])); |
| * // true |
| * ``` |
| * @param {String|Array} `str` The string to test. |
| * @param {String|Array} `patterns` One or more glob patterns to use for matching. |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Boolean} Returns true if any patterns match `str` |
| * @api public |
| */ |
| |
| micromatch.all = (str, patterns, options) => { |
| if (typeof str !== 'string') { |
| throw new TypeError(`Expected a string: "${util.inspect(str)}"`); |
| } |
| |
| return [].concat(patterns).every(p => picomatch(p, options)(str)); |
| }; |
| |
| /** |
| * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.capture(pattern, string[, options]); |
| * |
| * console.log(mm.capture('test/*.js', 'test/foo.js')); |
| * //=> ['foo'] |
| * console.log(mm.capture('test/*.js', 'foo/bar.css')); |
| * //=> null |
| * ``` |
| * @param {String} `glob` Glob pattern to use for matching. |
| * @param {String} `input` String to match |
| * @param {Object} `options` See available [options](#options) for changing how matches are performed |
| * @return {Boolean} Returns an array of captures if the input matches the glob pattern, otherwise `null`. |
| * @api public |
| */ |
| |
| micromatch.capture = (glob, input, options) => { |
| let posix = utils.isWindows(options); |
| let regex = picomatch.makeRe(String(glob), { ...options, capture: true }); |
| let match = regex.exec(posix ? utils.toPosixSlashes(input) : input); |
| |
| if (match) { |
| return match.slice(1).map(v => v === void 0 ? '' : v); |
| } |
| }; |
| |
| /** |
| * Create a regular expression from the given glob `pattern`. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * // mm.makeRe(pattern[, options]); |
| * |
| * console.log(mm.makeRe('*.js')); |
| * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/ |
| * ``` |
| * @param {String} `pattern` A glob pattern to convert to regex. |
| * @param {Object} `options` |
| * @return {RegExp} Returns a regex created from the given pattern. |
| * @api public |
| */ |
| |
| micromatch.makeRe = (...args) => picomatch.makeRe(...args); |
| |
| /** |
| * Scan a glob pattern to separate the pattern into segments. Used |
| * by the [split](#split) method. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * const state = mm.scan(pattern[, options]); |
| * ``` |
| * @param {String} `pattern` |
| * @param {Object} `options` |
| * @return {Object} Returns an object with |
| * @api public |
| */ |
| |
| micromatch.scan = (...args) => picomatch.scan(...args); |
| |
| /** |
| * Parse a glob pattern to create the source string for a regular |
| * expression. |
| * |
| * ```js |
| * const mm = require('micromatch'); |
| * const state = mm(pattern[, options]); |
| * ``` |
| * @param {String} `glob` |
| * @param {Object} `options` |
| * @return {Object} Returns an object with useful properties and output to be used as regex source string. |
| * @api public |
| */ |
| |
| micromatch.parse = (patterns, options) => { |
| let res = []; |
| for (let pattern of [].concat(patterns || [])) { |
| for (let str of braces(String(pattern), options)) { |
| res.push(picomatch.parse(str, options)); |
| } |
| } |
| return res; |
| }; |
| |
| /** |
| * Process the given brace `pattern`. |
| * |
| * ```js |
| * const { braces } = require('micromatch'); |
| * console.log(braces('foo/{a,b,c}/bar')); |
| * //=> [ 'foo/(a|b|c)/bar' ] |
| * |
| * console.log(braces('foo/{a,b,c}/bar', { expand: true })); |
| * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ] |
| * ``` |
| * @param {String} `pattern` String with brace pattern to process. |
| * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options. |
| * @return {Array} |
| * @api public |
| */ |
| |
| micromatch.braces = (pattern, options) => { |
| if (typeof pattern !== 'string') throw new TypeError('Expected a string'); |
| if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) { |
| return [pattern]; |
| } |
| return braces(pattern, options); |
| }; |
| |
| /** |
| * Expand braces |
| */ |
| |
| micromatch.braceExpand = (pattern, options) => { |
| if (typeof pattern !== 'string') throw new TypeError('Expected a string'); |
| return micromatch.braces(pattern, { ...options, expand: true }); |
| }; |
| |
| /** |
| * Expose micromatch |
| */ |
| |
| module.exports = micromatch; |
| |
| |
| /***/ }), |
| |
| /***/ 6867: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| /*! |
| * to-regex-range <https://github.com/micromatch/to-regex-range> |
| * |
| * Copyright (c) 2015-present, Jon Schlinkert. |
| * Released under the MIT License. |
| */ |
| |
| |
| |
| const isNumber = __nccwpck_require__(2840); |
| |
| const toRegexRange = (min, max, options) => { |
| if (isNumber(min) === false) { |
| throw new TypeError('toRegexRange: expected the first argument to be a number'); |
| } |
| |
| if (max === void 0 || min === max) { |
| return String(min); |
| } |
| |
| if (isNumber(max) === false) { |
| throw new TypeError('toRegexRange: expected the second argument to be a number.'); |
| } |
| |
| let opts = { relaxZeros: true, ...options }; |
| if (typeof opts.strictZeros === 'boolean') { |
| opts.relaxZeros = opts.strictZeros === false; |
| } |
| |
| let relax = String(opts.relaxZeros); |
| let shorthand = String(opts.shorthand); |
| let capture = String(opts.capture); |
| let wrap = String(opts.wrap); |
| let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap; |
| |
| if (toRegexRange.cache.hasOwnProperty(cacheKey)) { |
| return toRegexRange.cache[cacheKey].result; |
| } |
| |
| let a = Math.min(min, max); |
| let b = Math.max(min, max); |
| |
| if (Math.abs(a - b) === 1) { |
| let result = min + '|' + max; |
| if (opts.capture) { |
| return `(${result})`; |
| } |
| if (opts.wrap === false) { |
| return result; |
| } |
| return `(?:${result})`; |
| } |
| |
| let isPadded = hasPadding(min) || hasPadding(max); |
| let state = { min, max, a, b }; |
| let positives = []; |
| let negatives = []; |
| |
| if (isPadded) { |
| state.isPadded = isPadded; |
| state.maxLen = String(state.max).length; |
| } |
| |
| if (a < 0) { |
| let newMin = b < 0 ? Math.abs(b) : 1; |
| negatives = splitToPatterns(newMin, Math.abs(a), state, opts); |
| a = state.a = 0; |
| } |
| |
| if (b >= 0) { |
| positives = splitToPatterns(a, b, state, opts); |
| } |
| |
| state.negatives = negatives; |
| state.positives = positives; |
| state.result = collatePatterns(negatives, positives, opts); |
| |
| if (opts.capture === true) { |
| state.result = `(${state.result})`; |
| } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) { |
| state.result = `(?:${state.result})`; |
| } |
| |
| toRegexRange.cache[cacheKey] = state; |
| return state.result; |
| }; |
| |
| function collatePatterns(neg, pos, options) { |
| let onlyNegative = filterPatterns(neg, pos, '-', false, options) || []; |
| let onlyPositive = filterPatterns(pos, neg, '', false, options) || []; |
| let intersected = filterPatterns(neg, pos, '-?', true, options) || []; |
| let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive); |
| return subpatterns.join('|'); |
| } |
| |
| function splitToRanges(min, max) { |
| let nines = 1; |
| let zeros = 1; |
| |
| let stop = countNines(min, nines); |
| let stops = new Set([max]); |
| |
| while (min <= stop && stop <= max) { |
| stops.add(stop); |
| nines += 1; |
| stop = countNines(min, nines); |
| } |
| |
| stop = countZeros(max + 1, zeros) - 1; |
| |
| while (min < stop && stop <= max) { |
| stops.add(stop); |
| zeros += 1; |
| stop = countZeros(max + 1, zeros) - 1; |
| } |
| |
| stops = [...stops]; |
| stops.sort(compare); |
| return stops; |
| } |
| |
| /** |
| * Convert a range to a regex pattern |
| * @param {Number} `start` |
| * @param {Number} `stop` |
| * @return {String} |
| */ |
| |
| function rangeToPattern(start, stop, options) { |
| if (start === stop) { |
| return { pattern: start, count: [], digits: 0 }; |
| } |
| |
| let zipped = zip(start, stop); |
| let digits = zipped.length; |
| let pattern = ''; |
| let count = 0; |
| |
| for (let i = 0; i < digits; i++) { |
| let [startDigit, stopDigit] = zipped[i]; |
| |
| if (startDigit === stopDigit) { |
| pattern += startDigit; |
| |
| } else if (startDigit !== '0' || stopDigit !== '9') { |
| pattern += toCharacterClass(startDigit, stopDigit, options); |
| |
| } else { |
| count++; |
| } |
| } |
| |
| if (count) { |
| pattern += options.shorthand === true ? '\\d' : '[0-9]'; |
| } |
| |
| return { pattern, count: [count], digits }; |
| } |
| |
| function splitToPatterns(min, max, tok, options) { |
| let ranges = splitToRanges(min, max); |
| let tokens = []; |
| let start = min; |
| let prev; |
| |
| for (let i = 0; i < ranges.length; i++) { |
| let max = ranges[i]; |
| let obj = rangeToPattern(String(start), String(max), options); |
| let zeros = ''; |
| |
| if (!tok.isPadded && prev && prev.pattern === obj.pattern) { |
| if (prev.count.length > 1) { |
| prev.count.pop(); |
| } |
| |
| prev.count.push(obj.count[0]); |
| prev.string = prev.pattern + toQuantifier(prev.count); |
| start = max + 1; |
| continue; |
| } |
| |
| if (tok.isPadded) { |
| zeros = padZeros(max, tok, options); |
| } |
| |
| obj.string = zeros + obj.pattern + toQuantifier(obj.count); |
| tokens.push(obj); |
| start = max + 1; |
| prev = obj; |
| } |
| |
| return tokens; |
| } |
| |
| function filterPatterns(arr, comparison, prefix, intersection, options) { |
| let result = []; |
| |
| for (let ele of arr) { |
| let { string } = ele; |
| |
| // only push if _both_ are negative... |
| if (!intersection && !contains(comparison, 'string', string)) { |
| result.push(prefix + string); |
| } |
| |
| // or _both_ are positive |
| if (intersection && contains(comparison, 'string', string)) { |
| result.push(prefix + string); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Zip strings |
| */ |
| |
| function zip(a, b) { |
| let arr = []; |
| for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]); |
| return arr; |
| } |
| |
| function compare(a, b) { |
| return a > b ? 1 : b > a ? -1 : 0; |
| } |
| |
| function contains(arr, key, val) { |
| return arr.some(ele => ele[key] === val); |
| } |
| |
| function countNines(min, len) { |
| return Number(String(min).slice(0, -len) + '9'.repeat(len)); |
| } |
| |
| function countZeros(integer, zeros) { |
| return integer - (integer % Math.pow(10, zeros)); |
| } |
| |
| function toQuantifier(digits) { |
| let [start = 0, stop = ''] = digits; |
| if (stop || start > 1) { |
| return `{${start + (stop ? ',' + stop : '')}}`; |
| } |
| return ''; |
| } |
| |
| function toCharacterClass(a, b, options) { |
| return `[${a}${(b - a === 1) ? '' : '-'}${b}]`; |
| } |
| |
| function hasPadding(str) { |
| return /^-?(0+)\d/.test(str); |
| } |
| |
| function padZeros(value, tok, options) { |
| if (!tok.isPadded) { |
| return value; |
| } |
| |
| let diff = Math.abs(tok.maxLen - String(value).length); |
| let relax = options.relaxZeros !== false; |
| |
| switch (diff) { |
| case 0: |
| return ''; |
| case 1: |
| return relax ? '0?' : '0'; |
| case 2: |
| return relax ? '0{0,2}' : '00'; |
| default: { |
| return relax ? `0{0,${diff}}` : `0{${diff}}`; |
| } |
| } |
| } |
| |
| /** |
| * Cache |
| */ |
| |
| toRegexRange.cache = {}; |
| toRegexRange.clearCache = () => (toRegexRange.cache = {}); |
| |
| /** |
| * Expose `toRegexRange` |
| */ |
| |
| module.exports = toRegexRange; |
| |
| |
| /***/ }), |
| |
| /***/ 3664: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const taskManager = __nccwpck_require__(2708); |
| const async_1 = __nccwpck_require__(5679); |
| const stream_1 = __nccwpck_require__(4630); |
| const sync_1 = __nccwpck_require__(2405); |
| const settings_1 = __nccwpck_require__(952); |
| const utils = __nccwpck_require__(5444); |
| async function FastGlob(source, options) { |
| assertPatternsInput(source); |
| const works = getWorks(source, async_1.default, options); |
| const result = await Promise.all(works); |
| return utils.array.flatten(result); |
| } |
| // https://github.com/typescript-eslint/typescript-eslint/issues/60 |
| // eslint-disable-next-line no-redeclare |
| (function (FastGlob) { |
| function sync(source, options) { |
| assertPatternsInput(source); |
| const works = getWorks(source, sync_1.default, options); |
| return utils.array.flatten(works); |
| } |
| FastGlob.sync = sync; |
| function stream(source, options) { |
| assertPatternsInput(source); |
| const works = getWorks(source, stream_1.default, options); |
| /** |
| * The stream returned by the provider cannot work with an asynchronous iterator. |
| * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams. |
| * This affects performance (+25%). I don't see best solution right now. |
| */ |
| return utils.stream.merge(works); |
| } |
| FastGlob.stream = stream; |
| function generateTasks(source, options) { |
| assertPatternsInput(source); |
| const patterns = [].concat(source); |
| const settings = new settings_1.default(options); |
| return taskManager.generate(patterns, settings); |
| } |
| FastGlob.generateTasks = generateTasks; |
| function isDynamicPattern(source, options) { |
| assertPatternsInput(source); |
| const settings = new settings_1.default(options); |
| return utils.pattern.isDynamicPattern(source, settings); |
| } |
| FastGlob.isDynamicPattern = isDynamicPattern; |
| function escapePath(source) { |
| assertPatternsInput(source); |
| return utils.path.escape(source); |
| } |
| FastGlob.escapePath = escapePath; |
| })(FastGlob || (FastGlob = {})); |
| function getWorks(source, _Provider, options) { |
| const patterns = [].concat(source); |
| const settings = new settings_1.default(options); |
| const tasks = taskManager.generate(patterns, settings); |
| const provider = new _Provider(settings); |
| return tasks.map(provider.read, provider); |
| } |
| function assertPatternsInput(input) { |
| const source = [].concat(input); |
| const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item)); |
| if (!isValidSource) { |
| throw new TypeError('Patterns must be a string (non empty) or an array of strings'); |
| } |
| } |
| module.exports = FastGlob; |
| |
| |
| /***/ }), |
| |
| /***/ 2708: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0; |
| const utils = __nccwpck_require__(5444); |
| function generate(patterns, settings) { |
| const positivePatterns = getPositivePatterns(patterns); |
| const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore); |
| const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings)); |
| const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings)); |
| const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false); |
| const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true); |
| return staticTasks.concat(dynamicTasks); |
| } |
| exports.generate = generate; |
| function convertPatternsToTasks(positive, negative, dynamic) { |
| const positivePatternsGroup = groupPatternsByBaseDirectory(positive); |
| // When we have a global group – there is no reason to divide the patterns into independent tasks. |
| // In this case, the global task covers the rest. |
| if ('.' in positivePatternsGroup) { |
| const task = convertPatternGroupToTask('.', positive, negative, dynamic); |
| return [task]; |
| } |
| return convertPatternGroupsToTasks(positivePatternsGroup, negative, dynamic); |
| } |
| exports.convertPatternsToTasks = convertPatternsToTasks; |
| function getPositivePatterns(patterns) { |
| return utils.pattern.getPositivePatterns(patterns); |
| } |
| exports.getPositivePatterns = getPositivePatterns; |
| function getNegativePatternsAsPositive(patterns, ignore) { |
| const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore); |
| const positive = negative.map(utils.pattern.convertToPositivePattern); |
| return positive; |
| } |
| exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive; |
| function groupPatternsByBaseDirectory(patterns) { |
| const group = {}; |
| return patterns.reduce((collection, pattern) => { |
| const base = utils.pattern.getBaseDirectory(pattern); |
| if (base in collection) { |
| collection[base].push(pattern); |
| } |
| else { |
| collection[base] = [pattern]; |
| } |
| return collection; |
| }, group); |
| } |
| exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory; |
| function convertPatternGroupsToTasks(positive, negative, dynamic) { |
| return Object.keys(positive).map((base) => { |
| return convertPatternGroupToTask(base, positive[base], negative, dynamic); |
| }); |
| } |
| exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks; |
| function convertPatternGroupToTask(base, positive, negative, dynamic) { |
| return { |
| dynamic, |
| positive, |
| negative, |
| base, |
| patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern)) |
| }; |
| } |
| exports.convertPatternGroupToTask = convertPatternGroupToTask; |
| |
| |
| /***/ }), |
| |
| /***/ 5679: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const stream_1 = __nccwpck_require__(2083); |
| const provider_1 = __nccwpck_require__(257); |
| class ProviderAsync extends provider_1.default { |
| constructor() { |
| super(...arguments); |
| this._reader = new stream_1.default(this._settings); |
| } |
| read(task) { |
| const root = this._getRootDirectory(task); |
| const options = this._getReaderOptions(task); |
| const entries = []; |
| return new Promise((resolve, reject) => { |
| const stream = this.api(root, task, options); |
| stream.once('error', reject); |
| stream.on('data', (entry) => entries.push(options.transform(entry))); |
| stream.once('end', () => resolve(entries)); |
| }); |
| } |
| api(root, task, options) { |
| if (task.dynamic) { |
| return this._reader.dynamic(root, options); |
| } |
| return this._reader.static(task.patterns, options); |
| } |
| } |
| exports.default = ProviderAsync; |
| |
| |
| /***/ }), |
| |
| /***/ 6983: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const utils = __nccwpck_require__(5444); |
| const partial_1 = __nccwpck_require__(5295); |
| class DeepFilter { |
| constructor(_settings, _micromatchOptions) { |
| this._settings = _settings; |
| this._micromatchOptions = _micromatchOptions; |
| } |
| getFilter(basePath, positive, negative) { |
| const matcher = this._getMatcher(positive); |
| const negativeRe = this._getNegativePatternsRe(negative); |
| return (entry) => this._filter(basePath, entry, matcher, negativeRe); |
| } |
| _getMatcher(patterns) { |
| return new partial_1.default(patterns, this._settings, this._micromatchOptions); |
| } |
| _getNegativePatternsRe(patterns) { |
| const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern); |
| return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions); |
| } |
| _filter(basePath, entry, matcher, negativeRe) { |
| if (this._isSkippedByDeep(basePath, entry.path)) { |
| return false; |
| } |
| if (this._isSkippedSymbolicLink(entry)) { |
| return false; |
| } |
| const filepath = utils.path.removeLeadingDotSegment(entry.path); |
| if (this._isSkippedByPositivePatterns(filepath, matcher)) { |
| return false; |
| } |
| return this._isSkippedByNegativePatterns(filepath, negativeRe); |
| } |
| _isSkippedByDeep(basePath, entryPath) { |
| /** |
| * Avoid unnecessary depth calculations when it doesn't matter. |
| */ |
| if (this._settings.deep === Infinity) { |
| return false; |
| } |
| return this._getEntryLevel(basePath, entryPath) >= this._settings.deep; |
| } |
| _getEntryLevel(basePath, entryPath) { |
| const entryPathDepth = entryPath.split('/').length; |
| if (basePath === '') { |
| return entryPathDepth; |
| } |
| const basePathDepth = basePath.split('/').length; |
| return entryPathDepth - basePathDepth; |
| } |
| _isSkippedSymbolicLink(entry) { |
| return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink(); |
| } |
| _isSkippedByPositivePatterns(entryPath, matcher) { |
| return !this._settings.baseNameMatch && !matcher.match(entryPath); |
| } |
| _isSkippedByNegativePatterns(entryPath, patternsRe) { |
| return !utils.pattern.matchAny(entryPath, patternsRe); |
| } |
| } |
| exports.default = DeepFilter; |
| |
| |
| /***/ }), |
| |
| /***/ 1343: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const utils = __nccwpck_require__(5444); |
| class EntryFilter { |
| constructor(_settings, _micromatchOptions) { |
| this._settings = _settings; |
| this._micromatchOptions = _micromatchOptions; |
| this.index = new Map(); |
| } |
| getFilter(positive, negative) { |
| const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions); |
| const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions); |
| return (entry) => this._filter(entry, positiveRe, negativeRe); |
| } |
| _filter(entry, positiveRe, negativeRe) { |
| if (this._settings.unique && this._isDuplicateEntry(entry)) { |
| return false; |
| } |
| if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) { |
| return false; |
| } |
| if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) { |
| return false; |
| } |
| const filepath = this._settings.baseNameMatch ? entry.name : entry.path; |
| const isMatched = this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe); |
| if (this._settings.unique && isMatched) { |
| this._createIndexRecord(entry); |
| } |
| return isMatched; |
| } |
| _isDuplicateEntry(entry) { |
| return this.index.has(entry.path); |
| } |
| _createIndexRecord(entry) { |
| this.index.set(entry.path, undefined); |
| } |
| _onlyFileFilter(entry) { |
| return this._settings.onlyFiles && !entry.dirent.isFile(); |
| } |
| _onlyDirectoryFilter(entry) { |
| return this._settings.onlyDirectories && !entry.dirent.isDirectory(); |
| } |
| _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) { |
| if (!this._settings.absolute) { |
| return false; |
| } |
| const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath); |
| return utils.pattern.matchAny(fullpath, patternsRe); |
| } |
| _isMatchToPatterns(entryPath, patternsRe) { |
| const filepath = utils.path.removeLeadingDotSegment(entryPath); |
| return utils.pattern.matchAny(filepath, patternsRe); |
| } |
| } |
| exports.default = EntryFilter; |
| |
| |
| /***/ }), |
| |
| /***/ 6654: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const utils = __nccwpck_require__(5444); |
| class ErrorFilter { |
| constructor(_settings) { |
| this._settings = _settings; |
| } |
| getFilter() { |
| return (error) => this._isNonFatalError(error); |
| } |
| _isNonFatalError(error) { |
| return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors; |
| } |
| } |
| exports.default = ErrorFilter; |
| |
| |
| /***/ }), |
| |
| /***/ 2576: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const utils = __nccwpck_require__(5444); |
| class Matcher { |
| constructor(_patterns, _settings, _micromatchOptions) { |
| this._patterns = _patterns; |
| this._settings = _settings; |
| this._micromatchOptions = _micromatchOptions; |
| this._storage = []; |
| this._fillStorage(); |
| } |
| _fillStorage() { |
| /** |
| * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level). |
| * So, before expand patterns with brace expansion into separated patterns. |
| */ |
| const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns); |
| for (const pattern of patterns) { |
| const segments = this._getPatternSegments(pattern); |
| const sections = this._splitSegmentsIntoSections(segments); |
| this._storage.push({ |
| complete: sections.length <= 1, |
| pattern, |
| segments, |
| sections |
| }); |
| } |
| } |
| _getPatternSegments(pattern) { |
| const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions); |
| return parts.map((part) => { |
| const dynamic = utils.pattern.isDynamicPattern(part, this._settings); |
| if (!dynamic) { |
| return { |
| dynamic: false, |
| pattern: part |
| }; |
| } |
| return { |
| dynamic: true, |
| pattern: part, |
| patternRe: utils.pattern.makeRe(part, this._micromatchOptions) |
| }; |
| }); |
| } |
| _splitSegmentsIntoSections(segments) { |
| return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern)); |
| } |
| } |
| exports.default = Matcher; |
| |
| |
| /***/ }), |
| |
| /***/ 5295: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const matcher_1 = __nccwpck_require__(2576); |
| class PartialMatcher extends matcher_1.default { |
| match(filepath) { |
| const parts = filepath.split('/'); |
| const levels = parts.length; |
| const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels); |
| for (const pattern of patterns) { |
| const section = pattern.sections[0]; |
| /** |
| * In this case, the pattern has a globstar and we must read all directories unconditionally, |
| * but only if the level has reached the end of the first group. |
| * |
| * fixtures/{a,b}/** |
| * ^ true/false ^ always true |
| */ |
| if (!pattern.complete && levels > section.length) { |
| return true; |
| } |
| const match = parts.every((part, index) => { |
| const segment = pattern.segments[index]; |
| if (segment.dynamic && segment.patternRe.test(part)) { |
| return true; |
| } |
| if (!segment.dynamic && segment.pattern === part) { |
| return true; |
| } |
| return false; |
| }); |
| if (match) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| exports.default = PartialMatcher; |
| |
| |
| /***/ }), |
| |
| /***/ 257: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const path = __nccwpck_require__(5622); |
| const deep_1 = __nccwpck_require__(6983); |
| const entry_1 = __nccwpck_require__(1343); |
| const error_1 = __nccwpck_require__(6654); |
| const entry_2 = __nccwpck_require__(4029); |
| class Provider { |
| constructor(_settings) { |
| this._settings = _settings; |
| this.errorFilter = new error_1.default(this._settings); |
| this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions()); |
| this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions()); |
| this.entryTransformer = new entry_2.default(this._settings); |
| } |
| _getRootDirectory(task) { |
| return path.resolve(this._settings.cwd, task.base); |
| } |
| _getReaderOptions(task) { |
| const basePath = task.base === '.' ? '' : task.base; |
| return { |
| basePath, |
| pathSegmentSeparator: '/', |
| concurrency: this._settings.concurrency, |
| deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative), |
| entryFilter: this.entryFilter.getFilter(task.positive, task.negative), |
| errorFilter: this.errorFilter.getFilter(), |
| followSymbolicLinks: this._settings.followSymbolicLinks, |
| fs: this._settings.fs, |
| stats: this._settings.stats, |
| throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink, |
| transform: this.entryTransformer.getTransformer() |
| }; |
| } |
| _getMicromatchOptions() { |
| return { |
| dot: this._settings.dot, |
| matchBase: this._settings.baseNameMatch, |
| nobrace: !this._settings.braceExpansion, |
| nocase: !this._settings.caseSensitiveMatch, |
| noext: !this._settings.extglob, |
| noglobstar: !this._settings.globstar, |
| posix: true, |
| strictSlashes: false |
| }; |
| } |
| } |
| exports.default = Provider; |
| |
| |
| /***/ }), |
| |
| /***/ 4630: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const stream_1 = __nccwpck_require__(2413); |
| const stream_2 = __nccwpck_require__(2083); |
| const provider_1 = __nccwpck_require__(257); |
| class ProviderStream extends provider_1.default { |
| constructor() { |
| super(...arguments); |
| this._reader = new stream_2.default(this._settings); |
| } |
| read(task) { |
| const root = this._getRootDirectory(task); |
| const options = this._getReaderOptions(task); |
| const source = this.api(root, task, options); |
| const destination = new stream_1.Readable({ objectMode: true, read: () => { } }); |
| source |
| .once('error', (error) => destination.emit('error', error)) |
| .on('data', (entry) => destination.emit('data', options.transform(entry))) |
| .once('end', () => destination.emit('end')); |
| destination |
| .once('close', () => source.destroy()); |
| return destination; |
| } |
| api(root, task, options) { |
| if (task.dynamic) { |
| return this._reader.dynamic(root, options); |
| } |
| return this._reader.static(task.patterns, options); |
| } |
| } |
| exports.default = ProviderStream; |
| |
| |
| /***/ }), |
| |
| /***/ 2405: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const sync_1 = __nccwpck_require__(8821); |
| const provider_1 = __nccwpck_require__(257); |
| class ProviderSync extends provider_1.default { |
| constructor() { |
| super(...arguments); |
| this._reader = new sync_1.default(this._settings); |
| } |
| read(task) { |
| const root = this._getRootDirectory(task); |
| const options = this._getReaderOptions(task); |
| const entries = this.api(root, task, options); |
| return entries.map(options.transform); |
| } |
| api(root, task, options) { |
| if (task.dynamic) { |
| return this._reader.dynamic(root, options); |
| } |
| return this._reader.static(task.patterns, options); |
| } |
| } |
| exports.default = ProviderSync; |
| |
| |
| /***/ }), |
| |
| /***/ 4029: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const utils = __nccwpck_require__(5444); |
| class EntryTransformer { |
| constructor(_settings) { |
| this._settings = _settings; |
| } |
| getTransformer() { |
| return (entry) => this._transform(entry); |
| } |
| _transform(entry) { |
| let filepath = entry.path; |
| if (this._settings.absolute) { |
| filepath = utils.path.makeAbsolute(this._settings.cwd, filepath); |
| filepath = utils.path.unixify(filepath); |
| } |
| if (this._settings.markDirectories && entry.dirent.isDirectory()) { |
| filepath += '/'; |
| } |
| if (!this._settings.objectMode) { |
| return filepath; |
| } |
| return Object.assign(Object.assign({}, entry), { path: filepath }); |
| } |
| } |
| exports.default = EntryTransformer; |
| |
| |
| /***/ }), |
| |
| /***/ 8062: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const path = __nccwpck_require__(5622); |
| const fsStat = __nccwpck_require__(109); |
| const utils = __nccwpck_require__(5444); |
| class Reader { |
| constructor(_settings) { |
| this._settings = _settings; |
| this._fsStatSettings = new fsStat.Settings({ |
| followSymbolicLink: this._settings.followSymbolicLinks, |
| fs: this._settings.fs, |
| throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks |
| }); |
| } |
| _getFullEntryPath(filepath) { |
| return path.resolve(this._settings.cwd, filepath); |
| } |
| _makeEntry(stats, pattern) { |
| const entry = { |
| name: pattern, |
| path: pattern, |
| dirent: utils.fs.createDirentFromStats(pattern, stats) |
| }; |
| if (this._settings.stats) { |
| entry.stats = stats; |
| } |
| return entry; |
| } |
| _isFatalError(error) { |
| return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors; |
| } |
| } |
| exports.default = Reader; |
| |
| |
| /***/ }), |
| |
| /***/ 2083: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const stream_1 = __nccwpck_require__(2413); |
| const fsStat = __nccwpck_require__(109); |
| const fsWalk = __nccwpck_require__(6026); |
| const reader_1 = __nccwpck_require__(8062); |
| class ReaderStream extends reader_1.default { |
| constructor() { |
| super(...arguments); |
| this._walkStream = fsWalk.walkStream; |
| this._stat = fsStat.stat; |
| } |
| dynamic(root, options) { |
| return this._walkStream(root, options); |
| } |
| static(patterns, options) { |
| const filepaths = patterns.map(this._getFullEntryPath, this); |
| const stream = new stream_1.PassThrough({ objectMode: true }); |
| stream._write = (index, _enc, done) => { |
| return this._getEntry(filepaths[index], patterns[index], options) |
| .then((entry) => { |
| if (entry !== null && options.entryFilter(entry)) { |
| stream.push(entry); |
| } |
| if (index === filepaths.length - 1) { |
| stream.end(); |
| } |
| done(); |
| }) |
| .catch(done); |
| }; |
| for (let i = 0; i < filepaths.length; i++) { |
| stream.write(i); |
| } |
| return stream; |
| } |
| _getEntry(filepath, pattern, options) { |
| return this._getStat(filepath) |
| .then((stats) => this._makeEntry(stats, pattern)) |
| .catch((error) => { |
| if (options.errorFilter(error)) { |
| return null; |
| } |
| throw error; |
| }); |
| } |
| _getStat(filepath) { |
| return new Promise((resolve, reject) => { |
| this._stat(filepath, this._fsStatSettings, (error, stats) => { |
| return error === null ? resolve(stats) : reject(error); |
| }); |
| }); |
| } |
| } |
| exports.default = ReaderStream; |
| |
| |
| /***/ }), |
| |
| /***/ 8821: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const fsStat = __nccwpck_require__(109); |
| const fsWalk = __nccwpck_require__(6026); |
| const reader_1 = __nccwpck_require__(8062); |
| class ReaderSync extends reader_1.default { |
| constructor() { |
| super(...arguments); |
| this._walkSync = fsWalk.walkSync; |
| this._statSync = fsStat.statSync; |
| } |
| dynamic(root, options) { |
| return this._walkSync(root, options); |
| } |
| static(patterns, options) { |
| const entries = []; |
| for (const pattern of patterns) { |
| const filepath = this._getFullEntryPath(pattern); |
| const entry = this._getEntry(filepath, pattern, options); |
| if (entry === null || !options.entryFilter(entry)) { |
| continue; |
| } |
| entries.push(entry); |
| } |
| return entries; |
| } |
| _getEntry(filepath, pattern, options) { |
| try { |
| const stats = this._getStat(filepath); |
| return this._makeEntry(stats, pattern); |
| } |
| catch (error) { |
| if (options.errorFilter(error)) { |
| return null; |
| } |
| throw error; |
| } |
| } |
| _getStat(filepath) { |
| return this._statSync(filepath, this._fsStatSettings); |
| } |
| } |
| exports.default = ReaderSync; |
| |
| |
| /***/ }), |
| |
| /***/ 952: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0; |
| const fs = __nccwpck_require__(5747); |
| const os = __nccwpck_require__(2087); |
| /** |
| * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero. |
| * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107 |
| */ |
| const CPU_COUNT = Math.max(os.cpus().length, 1); |
| exports.DEFAULT_FILE_SYSTEM_ADAPTER = { |
| lstat: fs.lstat, |
| lstatSync: fs.lstatSync, |
| stat: fs.stat, |
| statSync: fs.statSync, |
| readdir: fs.readdir, |
| readdirSync: fs.readdirSync |
| }; |
| class Settings { |
| constructor(_options = {}) { |
| this._options = _options; |
| this.absolute = this._getValue(this._options.absolute, false); |
| this.baseNameMatch = this._getValue(this._options.baseNameMatch, false); |
| this.braceExpansion = this._getValue(this._options.braceExpansion, true); |
| this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true); |
| this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT); |
| this.cwd = this._getValue(this._options.cwd, process.cwd()); |
| this.deep = this._getValue(this._options.deep, Infinity); |
| this.dot = this._getValue(this._options.dot, false); |
| this.extglob = this._getValue(this._options.extglob, true); |
| this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true); |
| this.fs = this._getFileSystemMethods(this._options.fs); |
| this.globstar = this._getValue(this._options.globstar, true); |
| this.ignore = this._getValue(this._options.ignore, []); |
| this.markDirectories = this._getValue(this._options.markDirectories, false); |
| this.objectMode = this._getValue(this._options.objectMode, false); |
| this.onlyDirectories = this._getValue(this._options.onlyDirectories, false); |
| this.onlyFiles = this._getValue(this._options.onlyFiles, true); |
| this.stats = this._getValue(this._options.stats, false); |
| this.suppressErrors = this._getValue(this._options.suppressErrors, false); |
| this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false); |
| this.unique = this._getValue(this._options.unique, true); |
| if (this.onlyDirectories) { |
| this.onlyFiles = false; |
| } |
| if (this.stats) { |
| this.objectMode = true; |
| } |
| } |
| _getValue(option, value) { |
| return option === undefined ? value : option; |
| } |
| _getFileSystemMethods(methods = {}) { |
| return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods); |
| } |
| } |
| exports.default = Settings; |
| |
| |
| /***/ }), |
| |
| /***/ 5325: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.splitWhen = exports.flatten = void 0; |
| function flatten(items) { |
| return items.reduce((collection, item) => [].concat(collection, item), []); |
| } |
| exports.flatten = flatten; |
| function splitWhen(items, predicate) { |
| const result = [[]]; |
| let groupIndex = 0; |
| for (const item of items) { |
| if (predicate(item)) { |
| groupIndex++; |
| result[groupIndex] = []; |
| } |
| else { |
| result[groupIndex].push(item); |
| } |
| } |
| return result; |
| } |
| exports.splitWhen = splitWhen; |
| |
| |
| /***/ }), |
| |
| /***/ 1230: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.isEnoentCodeError = void 0; |
| function isEnoentCodeError(error) { |
| return error.code === 'ENOENT'; |
| } |
| exports.isEnoentCodeError = isEnoentCodeError; |
| |
| |
| /***/ }), |
| |
| /***/ 7543: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.createDirentFromStats = void 0; |
| class DirentFromStats { |
| constructor(name, stats) { |
| this.name = name; |
| this.isBlockDevice = stats.isBlockDevice.bind(stats); |
| this.isCharacterDevice = stats.isCharacterDevice.bind(stats); |
| this.isDirectory = stats.isDirectory.bind(stats); |
| this.isFIFO = stats.isFIFO.bind(stats); |
| this.isFile = stats.isFile.bind(stats); |
| this.isSocket = stats.isSocket.bind(stats); |
| this.isSymbolicLink = stats.isSymbolicLink.bind(stats); |
| } |
| } |
| function createDirentFromStats(name, stats) { |
| return new DirentFromStats(name, stats); |
| } |
| exports.createDirentFromStats = createDirentFromStats; |
| |
| |
| /***/ }), |
| |
| /***/ 5444: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0; |
| const array = __nccwpck_require__(5325); |
| exports.array = array; |
| const errno = __nccwpck_require__(1230); |
| exports.errno = errno; |
| const fs = __nccwpck_require__(7543); |
| exports.fs = fs; |
| const path = __nccwpck_require__(3873); |
| exports.path = path; |
| const pattern = __nccwpck_require__(1221); |
| exports.pattern = pattern; |
| const stream = __nccwpck_require__(8382); |
| exports.stream = stream; |
| const string = __nccwpck_require__(2203); |
| exports.string = string; |
| |
| |
| /***/ }), |
| |
| /***/ 3873: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.removeLeadingDotSegment = exports.escape = exports.makeAbsolute = exports.unixify = void 0; |
| const path = __nccwpck_require__(5622); |
| const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\ |
| const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g; |
| /** |
| * Designed to work only with simple paths: `dir\\file`. |
| */ |
| function unixify(filepath) { |
| return filepath.replace(/\\/g, '/'); |
| } |
| exports.unixify = unixify; |
| function makeAbsolute(cwd, filepath) { |
| return path.resolve(cwd, filepath); |
| } |
| exports.makeAbsolute = makeAbsolute; |
| function escape(pattern) { |
| return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2'); |
| } |
| exports.escape = escape; |
| function removeLeadingDotSegment(entry) { |
| // We do not use `startsWith` because this is 10x slower than current implementation for some cases. |
| // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with |
| if (entry.charAt(0) === '.') { |
| const secondCharactery = entry.charAt(1); |
| if (secondCharactery === '/' || secondCharactery === '\\') { |
| return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT); |
| } |
| } |
| return entry; |
| } |
| exports.removeLeadingDotSegment = removeLeadingDotSegment; |
| |
| |
| /***/ }), |
| |
| /***/ 1221: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0; |
| const path = __nccwpck_require__(5622); |
| const globParent = __nccwpck_require__(4655); |
| const micromatch = __nccwpck_require__(3913); |
| const picomatch = __nccwpck_require__(8569); |
| const GLOBSTAR = '**'; |
| const ESCAPE_SYMBOL = '\\'; |
| const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/; |
| const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[.*]/; |
| const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\(.*\|.*\)/; |
| const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\(.*\)/; |
| const BRACE_EXPANSIONS_SYMBOLS_RE = /{.*(?:,|\.\.).*}/; |
| function isStaticPattern(pattern, options = {}) { |
| return !isDynamicPattern(pattern, options); |
| } |
| exports.isStaticPattern = isStaticPattern; |
| function isDynamicPattern(pattern, options = {}) { |
| /** |
| * A special case with an empty string is necessary for matching patterns that start with a forward slash. |
| * An empty string cannot be a dynamic pattern. |
| * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'. |
| */ |
| if (pattern === '') { |
| return false; |
| } |
| /** |
| * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check |
| * filepath directly (without read directory). |
| */ |
| if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) { |
| return true; |
| } |
| if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) { |
| return true; |
| } |
| if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) { |
| return true; |
| } |
| if (options.braceExpansion !== false && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) { |
| return true; |
| } |
| return false; |
| } |
| exports.isDynamicPattern = isDynamicPattern; |
| function convertToPositivePattern(pattern) { |
| return isNegativePattern(pattern) ? pattern.slice(1) : pattern; |
| } |
| exports.convertToPositivePattern = convertToPositivePattern; |
| function convertToNegativePattern(pattern) { |
| return '!' + pattern; |
| } |
| exports.convertToNegativePattern = convertToNegativePattern; |
| function isNegativePattern(pattern) { |
| return pattern.startsWith('!') && pattern[1] !== '('; |
| } |
| exports.isNegativePattern = isNegativePattern; |
| function isPositivePattern(pattern) { |
| return !isNegativePattern(pattern); |
| } |
| exports.isPositivePattern = isPositivePattern; |
| function getNegativePatterns(patterns) { |
| return patterns.filter(isNegativePattern); |
| } |
| exports.getNegativePatterns = getNegativePatterns; |
| function getPositivePatterns(patterns) { |
| return patterns.filter(isPositivePattern); |
| } |
| exports.getPositivePatterns = getPositivePatterns; |
| function getBaseDirectory(pattern) { |
| return globParent(pattern, { flipBackslashes: false }); |
| } |
| exports.getBaseDirectory = getBaseDirectory; |
| function hasGlobStar(pattern) { |
| return pattern.includes(GLOBSTAR); |
| } |
| exports.hasGlobStar = hasGlobStar; |
| function endsWithSlashGlobStar(pattern) { |
| return pattern.endsWith('/' + GLOBSTAR); |
| } |
| exports.endsWithSlashGlobStar = endsWithSlashGlobStar; |
| function isAffectDepthOfReadingPattern(pattern) { |
| const basename = path.basename(pattern); |
| return endsWithSlashGlobStar(pattern) || isStaticPattern(basename); |
| } |
| exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern; |
| function expandPatternsWithBraceExpansion(patterns) { |
| return patterns.reduce((collection, pattern) => { |
| return collection.concat(expandBraceExpansion(pattern)); |
| }, []); |
| } |
| exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion; |
| function expandBraceExpansion(pattern) { |
| return micromatch.braces(pattern, { |
| expand: true, |
| nodupes: true |
| }); |
| } |
| exports.expandBraceExpansion = expandBraceExpansion; |
| function getPatternParts(pattern, options) { |
| let { parts } = picomatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true })); |
| /** |
| * The scan method returns an empty array in some cases. |
| * See micromatch/picomatch#58 for more details. |
| */ |
| if (parts.length === 0) { |
| parts = [pattern]; |
| } |
| /** |
| * The scan method does not return an empty part for the pattern with a forward slash. |
| * This is another part of micromatch/picomatch#58. |
| */ |
| if (parts[0].startsWith('/')) { |
| parts[0] = parts[0].slice(1); |
| parts.unshift(''); |
| } |
| return parts; |
| } |
| exports.getPatternParts = getPatternParts; |
| function makeRe(pattern, options) { |
| return micromatch.makeRe(pattern, options); |
| } |
| exports.makeRe = makeRe; |
| function convertPatternsToRe(patterns, options) { |
| return patterns.map((pattern) => makeRe(pattern, options)); |
| } |
| exports.convertPatternsToRe = convertPatternsToRe; |
| function matchAny(entry, patternsRe) { |
| return patternsRe.some((patternRe) => patternRe.test(entry)); |
| } |
| exports.matchAny = matchAny; |
| |
| |
| /***/ }), |
| |
| /***/ 8382: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.merge = void 0; |
| const merge2 = __nccwpck_require__(2578); |
| function merge(streams) { |
| const mergedStream = merge2(streams); |
| streams.forEach((stream) => { |
| stream.once('error', (error) => mergedStream.emit('error', error)); |
| }); |
| mergedStream.once('close', () => propagateCloseEventToSources(streams)); |
| mergedStream.once('end', () => propagateCloseEventToSources(streams)); |
| return mergedStream; |
| } |
| exports.merge = merge; |
| function propagateCloseEventToSources(streams) { |
| streams.forEach((stream) => stream.emit('close')); |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2203: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.isEmpty = exports.isString = void 0; |
| function isString(input) { |
| return typeof input === 'string'; |
| } |
| exports.isString = isString; |
| function isEmpty(input) { |
| return input === ''; |
| } |
| exports.isEmpty = isEmpty; |
| |
| |
| /***/ }), |
| |
| /***/ 7340: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| var reusify = __nccwpck_require__(2113) |
| |
| function fastqueue (context, worker, concurrency) { |
| if (typeof context === 'function') { |
| concurrency = worker |
| worker = context |
| context = null |
| } |
| |
| if (concurrency < 1) { |
| throw new Error('fastqueue concurrency must be greater than 1') |
| } |
| |
| var cache = reusify(Task) |
| var queueHead = null |
| var queueTail = null |
| var _running = 0 |
| var errorHandler = null |
| |
| var self = { |
| push: push, |
| drain: noop, |
| saturated: noop, |
| pause: pause, |
| paused: false, |
| concurrency: concurrency, |
| running: running, |
| resume: resume, |
| idle: idle, |
| length: length, |
| getQueue: getQueue, |
| unshift: unshift, |
| empty: noop, |
| kill: kill, |
| killAndDrain: killAndDrain, |
| error: error |
| } |
| |
| return self |
| |
| function running () { |
| return _running |
| } |
| |
| function pause () { |
| self.paused = true |
| } |
| |
| function length () { |
| var current = queueHead |
| var counter = 0 |
| |
| while (current) { |
| current = current.next |
| counter++ |
| } |
| |
| return counter |
| } |
| |
| function getQueue () { |
| var current = queueHead |
| var tasks = [] |
| |
| while (current) { |
| tasks.push(current.value) |
| current = current.next |
| } |
| |
| return tasks |
| } |
| |
| function resume () { |
| if (!self.paused) return |
| self.paused = false |
| for (var i = 0; i < self.concurrency; i++) { |
| _running++ |
| release() |
| } |
| } |
| |
| function idle () { |
| return _running === 0 && self.length() === 0 |
| } |
| |
| function push (value, done) { |
| var current = cache.get() |
| |
| current.context = context |
| current.release = release |
| current.value = value |
| current.callback = done || noop |
| current.errorHandler = errorHandler |
| |
| if (_running === self.concurrency || self.paused) { |
| if (queueTail) { |
| queueTail.next = current |
| queueTail = current |
| } else { |
| queueHead = current |
| queueTail = current |
| self.saturated() |
| } |
| } else { |
| _running++ |
| worker.call(context, current.value, current.worked) |
| } |
| } |
| |
| function unshift (value, done) { |
| var current = cache.get() |
| |
| current.context = context |
| current.release = release |
| current.value = value |
| current.callback = done || noop |
| |
| if (_running === self.concurrency || self.paused) { |
| if (queueHead) { |
| current.next = queueHead |
| queueHead = current |
| } else { |
| queueHead = current |
| queueTail = current |
| self.saturated() |
| } |
| } else { |
| _running++ |
| worker.call(context, current.value, current.worked) |
| } |
| } |
| |
| function release (holder) { |
| if (holder) { |
| cache.release(holder) |
| } |
| var next = queueHead |
| if (next) { |
| if (!self.paused) { |
| if (queueTail === queueHead) { |
| queueTail = null |
| } |
| queueHead = next.next |
| next.next = null |
| worker.call(context, next.value, next.worked) |
| if (queueTail === null) { |
| self.empty() |
| } |
| } else { |
| _running-- |
| } |
| } else if (--_running === 0) { |
| self.drain() |
| } |
| } |
| |
| function kill () { |
| queueHead = null |
| queueTail = null |
| self.drain = noop |
| } |
| |
| function killAndDrain () { |
| queueHead = null |
| queueTail = null |
| self.drain() |
| self.drain = noop |
| } |
| |
| function error (handler) { |
| errorHandler = handler |
| } |
| } |
| |
| function noop () {} |
| |
| function Task () { |
| this.value = null |
| this.callback = noop |
| this.next = null |
| this.release = noop |
| this.context = null |
| this.errorHandler = null |
| |
| var self = this |
| |
| this.worked = function worked (err, result) { |
| var callback = self.callback |
| var errorHandler = self.errorHandler |
| var val = self.value |
| self.value = null |
| self.callback = noop |
| if (self.errorHandler) { |
| errorHandler(err, val) |
| } |
| callback.call(self.context, err, result) |
| self.release(self) |
| } |
| } |
| |
| module.exports = fastqueue |
| |
| |
| /***/ }), |
| |
| /***/ 4655: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| var isGlob = __nccwpck_require__(4466); |
| var pathPosixDirname = __nccwpck_require__(5622).posix.dirname; |
| var isWin32 = __nccwpck_require__(2087).platform() === 'win32'; |
| |
| var slash = '/'; |
| var backslash = /\\/g; |
| var enclosure = /[\{\[].*[\/]*.*[\}\]]$/; |
| var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/; |
| var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g; |
| |
| /** |
| * @param {string} str |
| * @param {Object} opts |
| * @param {boolean} [opts.flipBackslashes=true] |
| */ |
| module.exports = function globParent(str, opts) { |
| var options = Object.assign({ flipBackslashes: true }, opts); |
| |
| // flip windows path separators |
| if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) { |
| str = str.replace(backslash, slash); |
| } |
| |
| // special case for strings ending in enclosure containing path separator |
| if (enclosure.test(str)) { |
| str += slash; |
| } |
| |
| // preserves full path in case of trailing path separator |
| str += 'a'; |
| |
| // remove path parts that are globby |
| do { |
| str = pathPosixDirname(str); |
| } while (isGlob(str) || globby.test(str)); |
| |
| // remove escape chars and return result |
| return str.replace(escaped, '$1'); |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 6457: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const types_1 = __nccwpck_require__(4597); |
| function createRejection(error, ...beforeErrorGroups) { |
| const promise = (async () => { |
| if (error instanceof types_1.RequestError) { |
| try { |
| for (const hooks of beforeErrorGroups) { |
| if (hooks) { |
| for (const hook of hooks) { |
| // eslint-disable-next-line no-await-in-loop |
| error = await hook(error); |
| } |
| } |
| } |
| } |
| catch (error_) { |
| error = error_; |
| } |
| } |
| throw error; |
| })(); |
| const returnPromise = () => promise; |
| promise.json = returnPromise; |
| promise.text = returnPromise; |
| promise.buffer = returnPromise; |
| promise.on = returnPromise; |
| return promise; |
| } |
| exports.default = createRejection; |
| |
| |
| /***/ }), |
| |
| /***/ 6056: |
| /***/ (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 __exportStar = (this && this.__exportStar) || function(m, exports) { |
| for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const events_1 = __nccwpck_require__(8614); |
| const is_1 = __nccwpck_require__(7678); |
| const PCancelable = __nccwpck_require__(9072); |
| const types_1 = __nccwpck_require__(4597); |
| const parse_body_1 = __nccwpck_require__(8220); |
| const core_1 = __nccwpck_require__(94); |
| const proxy_events_1 = __nccwpck_require__(3021); |
| const get_buffer_1 = __nccwpck_require__(4500); |
| const is_response_ok_1 = __nccwpck_require__(9298); |
| const proxiedRequestEvents = [ |
| 'request', |
| 'response', |
| 'redirect', |
| 'uploadProgress', |
| 'downloadProgress' |
| ]; |
| function asPromise(normalizedOptions) { |
| let globalRequest; |
| let globalResponse; |
| const emitter = new events_1.EventEmitter(); |
| const promise = new PCancelable((resolve, reject, onCancel) => { |
| const makeRequest = (retryCount) => { |
| const request = new core_1.default(undefined, normalizedOptions); |
| request.retryCount = retryCount; |
| request._noPipe = true; |
| onCancel(() => request.destroy()); |
| onCancel.shouldReject = false; |
| onCancel(() => reject(new types_1.CancelError(request))); |
| globalRequest = request; |
| request.once('response', async (response) => { |
| var _a; |
| response.retryCount = retryCount; |
| if (response.request.aborted) { |
| // Canceled while downloading - will throw a `CancelError` or `TimeoutError` error |
| return; |
| } |
| // Download body |
| let rawBody; |
| try { |
| rawBody = await get_buffer_1.default(request); |
| response.rawBody = rawBody; |
| } |
| catch (_b) { |
| // The same error is caught below. |
| // See request.once('error') |
| return; |
| } |
| if (request._isAboutToError) { |
| return; |
| } |
| // Parse body |
| const contentEncoding = ((_a = response.headers['content-encoding']) !== null && _a !== void 0 ? _a : '').toLowerCase(); |
| const isCompressed = ['gzip', 'deflate', 'br'].includes(contentEncoding); |
| const { options } = request; |
| if (isCompressed && !options.decompress) { |
| response.body = rawBody; |
| } |
| else { |
| try { |
| response.body = parse_body_1.default(response, options.responseType, options.parseJson, options.encoding); |
| } |
| catch (error) { |
| // Fallback to `utf8` |
| response.body = rawBody.toString(); |
| if (is_response_ok_1.isResponseOk(response)) { |
| request._beforeError(error); |
| return; |
| } |
| } |
| } |
| try { |
| for (const [index, hook] of options.hooks.afterResponse.entries()) { |
| // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise |
| // eslint-disable-next-line no-await-in-loop |
| response = await hook(response, async (updatedOptions) => { |
| const typedOptions = core_1.default.normalizeArguments(undefined, { |
| ...updatedOptions, |
| retry: { |
| calculateDelay: () => 0 |
| }, |
| throwHttpErrors: false, |
| resolveBodyOnly: false |
| }, options); |
| // Remove any further hooks for that request, because we'll call them anyway. |
| // The loop continues. We don't want duplicates (asPromise recursion). |
| typedOptions.hooks.afterResponse = typedOptions.hooks.afterResponse.slice(0, index); |
| for (const hook of typedOptions.hooks.beforeRetry) { |
| // eslint-disable-next-line no-await-in-loop |
| await hook(typedOptions); |
| } |
| const promise = asPromise(typedOptions); |
| onCancel(() => { |
| promise.catch(() => { }); |
| promise.cancel(); |
| }); |
| return promise; |
| }); |
| } |
| } |
| catch (error) { |
| request._beforeError(new types_1.RequestError(error.message, error, request)); |
| return; |
| } |
| if (!is_response_ok_1.isResponseOk(response)) { |
| request._beforeError(new types_1.HTTPError(response)); |
| return; |
| } |
| globalResponse = response; |
| resolve(request.options.resolveBodyOnly ? response.body : response); |
| }); |
| const onError = (error) => { |
| if (promise.isCanceled) { |
| return; |
| } |
| const { options } = request; |
| if (error instanceof types_1.HTTPError && !options.throwHttpErrors) { |
| const { response } = error; |
| resolve(request.options.resolveBodyOnly ? response.body : response); |
| return; |
| } |
| reject(error); |
| }; |
| request.once('error', onError); |
| const previousBody = request.options.body; |
| request.once('retry', (newRetryCount, error) => { |
| var _a, _b; |
| if (previousBody === ((_a = error.request) === null || _a === void 0 ? void 0 : _a.options.body) && is_1.default.nodeStream((_b = error.request) === null || _b === void 0 ? void 0 : _b.options.body)) { |
| onError(error); |
| return; |
| } |
| makeRequest(newRetryCount); |
| }); |
| proxy_events_1.default(request, emitter, proxiedRequestEvents); |
| }; |
| makeRequest(0); |
| }); |
| promise.on = (event, fn) => { |
| emitter.on(event, fn); |
| return promise; |
| }; |
| const shortcut = (responseType) => { |
| const newPromise = (async () => { |
| // Wait until downloading has ended |
| await promise; |
| const { options } = globalResponse.request; |
| return parse_body_1.default(globalResponse, responseType, options.parseJson, options.encoding); |
| })(); |
| Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise)); |
| return newPromise; |
| }; |
| promise.json = () => { |
| const { headers } = globalRequest.options; |
| if (!globalRequest.writableFinished && headers.accept === undefined) { |
| headers.accept = 'application/json'; |
| } |
| return shortcut('json'); |
| }; |
| promise.buffer = () => shortcut('buffer'); |
| promise.text = () => shortcut('text'); |
| return promise; |
| } |
| exports.default = asPromise; |
| __exportStar(__nccwpck_require__(4597), exports); |
| |
| |
| /***/ }), |
| |
| /***/ 1048: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const is_1 = __nccwpck_require__(7678); |
| const normalizeArguments = (options, defaults) => { |
| if (is_1.default.null_(options.encoding)) { |
| throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead'); |
| } |
| is_1.assert.any([is_1.default.string, is_1.default.undefined], options.encoding); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.resolveBodyOnly); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.methodRewriting); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.isStream); |
| is_1.assert.any([is_1.default.string, is_1.default.undefined], options.responseType); |
| // `options.responseType` |
| if (options.responseType === undefined) { |
| options.responseType = 'text'; |
| } |
| // `options.retry` |
| const { retry } = options; |
| if (defaults) { |
| options.retry = { ...defaults.retry }; |
| } |
| else { |
| options.retry = { |
| calculateDelay: retryObject => retryObject.computedValue, |
| limit: 0, |
| methods: [], |
| statusCodes: [], |
| errorCodes: [], |
| maxRetryAfter: undefined |
| }; |
| } |
| if (is_1.default.object(retry)) { |
| options.retry = { |
| ...options.retry, |
| ...retry |
| }; |
| options.retry.methods = [...new Set(options.retry.methods.map(method => method.toUpperCase()))]; |
| options.retry.statusCodes = [...new Set(options.retry.statusCodes)]; |
| options.retry.errorCodes = [...new Set(options.retry.errorCodes)]; |
| } |
| else if (is_1.default.number(retry)) { |
| options.retry.limit = retry; |
| } |
| if (is_1.default.undefined(options.retry.maxRetryAfter)) { |
| options.retry.maxRetryAfter = Math.min( |
| // TypeScript is not smart enough to handle `.filter(x => is.number(x))`. |
| // eslint-disable-next-line unicorn/no-fn-reference-in-iterator |
| ...[options.timeout.request, options.timeout.connect].filter(is_1.default.number)); |
| } |
| // `options.pagination` |
| if (is_1.default.object(options.pagination)) { |
| if (defaults) { |
| options.pagination = { |
| ...defaults.pagination, |
| ...options.pagination |
| }; |
| } |
| const { pagination } = options; |
| if (!is_1.default.function_(pagination.transform)) { |
| throw new Error('`options.pagination.transform` must be implemented'); |
| } |
| if (!is_1.default.function_(pagination.shouldContinue)) { |
| throw new Error('`options.pagination.shouldContinue` must be implemented'); |
| } |
| if (!is_1.default.function_(pagination.filter)) { |
| throw new TypeError('`options.pagination.filter` must be implemented'); |
| } |
| if (!is_1.default.function_(pagination.paginate)) { |
| throw new Error('`options.pagination.paginate` must be implemented'); |
| } |
| } |
| // JSON mode |
| if (options.responseType === 'json' && options.headers.accept === undefined) { |
| options.headers.accept = 'application/json'; |
| } |
| return options; |
| }; |
| exports.default = normalizeArguments; |
| |
| |
| /***/ }), |
| |
| /***/ 8220: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const types_1 = __nccwpck_require__(4597); |
| const parseBody = (response, responseType, parseJson, encoding) => { |
| const { rawBody } = response; |
| try { |
| if (responseType === 'text') { |
| return rawBody.toString(encoding); |
| } |
| if (responseType === 'json') { |
| return rawBody.length === 0 ? '' : parseJson(rawBody.toString()); |
| } |
| if (responseType === 'buffer') { |
| return rawBody; |
| } |
| throw new types_1.ParseError({ |
| message: `Unknown body type '${responseType}'`, |
| name: 'Error' |
| }, response); |
| } |
| catch (error) { |
| throw new types_1.ParseError(error, response); |
| } |
| }; |
| exports.default = parseBody; |
| |
| |
| /***/ }), |
| |
| /***/ 4597: |
| /***/ (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 __exportStar = (this && this.__exportStar) || function(m, exports) { |
| for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.CancelError = exports.ParseError = void 0; |
| const core_1 = __nccwpck_require__(94); |
| /** |
| An error to be thrown when server response code is 2xx, and parsing body fails. |
| Includes a `response` property. |
| */ |
| class ParseError extends core_1.RequestError { |
| constructor(error, response) { |
| const { options } = response.request; |
| super(`${error.message} in "${options.url.toString()}"`, error, response.request); |
| this.name = 'ParseError'; |
| } |
| } |
| exports.ParseError = ParseError; |
| /** |
| An error to be thrown when the request is aborted with `.cancel()`. |
| */ |
| class CancelError extends core_1.RequestError { |
| constructor(request) { |
| super('Promise was canceled', {}, request); |
| this.name = 'CancelError'; |
| } |
| get isCanceled() { |
| return true; |
| } |
| } |
| exports.CancelError = CancelError; |
| __exportStar(__nccwpck_require__(94), exports); |
| |
| |
| /***/ }), |
| |
| /***/ 3462: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.retryAfterStatusCodes = void 0; |
| exports.retryAfterStatusCodes = new Set([413, 429, 503]); |
| const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter }) => { |
| if (attemptCount > retryOptions.limit) { |
| return 0; |
| } |
| const hasMethod = retryOptions.methods.includes(error.options.method); |
| const hasErrorCode = retryOptions.errorCodes.includes(error.code); |
| const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode); |
| if (!hasMethod || (!hasErrorCode && !hasStatusCode)) { |
| return 0; |
| } |
| if (error.response) { |
| if (retryAfter) { |
| if (retryOptions.maxRetryAfter === undefined || retryAfter > retryOptions.maxRetryAfter) { |
| return 0; |
| } |
| return retryAfter; |
| } |
| if (error.response.statusCode === 413) { |
| return 0; |
| } |
| } |
| const noise = Math.random() * 100; |
| return ((2 ** (attemptCount - 1)) * 1000) + noise; |
| }; |
| exports.default = calculateRetryDelay; |
| |
| |
| /***/ }), |
| |
| /***/ 94: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.UnsupportedProtocolError = exports.ReadError = exports.TimeoutError = exports.UploadError = exports.CacheError = exports.HTTPError = exports.MaxRedirectsError = exports.RequestError = exports.setNonEnumerableProperties = exports.knownHookEvents = exports.withoutBody = exports.kIsNormalizedAlready = void 0; |
| const util_1 = __nccwpck_require__(1669); |
| const stream_1 = __nccwpck_require__(2413); |
| const fs_1 = __nccwpck_require__(5747); |
| const url_1 = __nccwpck_require__(8835); |
| const http = __nccwpck_require__(8605); |
| const http_1 = __nccwpck_require__(8605); |
| const https = __nccwpck_require__(7211); |
| const http_timer_1 = __nccwpck_require__(8097); |
| const cacheable_lookup_1 = __nccwpck_require__(2286); |
| const CacheableRequest = __nccwpck_require__(8116); |
| const decompressResponse = __nccwpck_require__(2391); |
| // @ts-expect-error Missing types |
| const http2wrapper = __nccwpck_require__(4645); |
| const lowercaseKeys = __nccwpck_require__(9662); |
| const is_1 = __nccwpck_require__(7678); |
| const get_body_size_1 = __nccwpck_require__(4564); |
| const is_form_data_1 = __nccwpck_require__(40); |
| const proxy_events_1 = __nccwpck_require__(3021); |
| const timed_out_1 = __nccwpck_require__(2454); |
| const url_to_options_1 = __nccwpck_require__(8026); |
| const options_to_url_1 = __nccwpck_require__(9219); |
| const weakable_map_1 = __nccwpck_require__(7288); |
| const get_buffer_1 = __nccwpck_require__(4500); |
| const dns_ip_version_1 = __nccwpck_require__(4993); |
| const is_response_ok_1 = __nccwpck_require__(9298); |
| const deprecation_warning_1 = __nccwpck_require__(397); |
| const normalize_arguments_1 = __nccwpck_require__(1048); |
| const calculate_retry_delay_1 = __nccwpck_require__(3462); |
| let globalDnsCache; |
| const kRequest = Symbol('request'); |
| const kResponse = Symbol('response'); |
| const kResponseSize = Symbol('responseSize'); |
| const kDownloadedSize = Symbol('downloadedSize'); |
| const kBodySize = Symbol('bodySize'); |
| const kUploadedSize = Symbol('uploadedSize'); |
| const kServerResponsesPiped = Symbol('serverResponsesPiped'); |
| const kUnproxyEvents = Symbol('unproxyEvents'); |
| const kIsFromCache = Symbol('isFromCache'); |
| const kCancelTimeouts = Symbol('cancelTimeouts'); |
| const kStartedReading = Symbol('startedReading'); |
| const kStopReading = Symbol('stopReading'); |
| const kTriggerRead = Symbol('triggerRead'); |
| const kBody = Symbol('body'); |
| const kJobs = Symbol('jobs'); |
| const kOriginalResponse = Symbol('originalResponse'); |
| const kRetryTimeout = Symbol('retryTimeout'); |
| exports.kIsNormalizedAlready = Symbol('isNormalizedAlready'); |
| const supportsBrotli = is_1.default.string(process.versions.brotli); |
| exports.withoutBody = new Set(['GET', 'HEAD']); |
| exports.knownHookEvents = [ |
| 'init', |
| 'beforeRequest', |
| 'beforeRedirect', |
| 'beforeError', |
| 'beforeRetry', |
| // Promise-Only |
| 'afterResponse' |
| ]; |
| function validateSearchParameters(searchParameters) { |
| // eslint-disable-next-line guard-for-in |
| for (const key in searchParameters) { |
| const value = searchParameters[key]; |
| if (!is_1.default.string(value) && !is_1.default.number(value) && !is_1.default.boolean(value) && !is_1.default.null_(value) && !is_1.default.undefined(value)) { |
| throw new TypeError(`The \`searchParams\` value '${String(value)}' must be a string, number, boolean or null`); |
| } |
| } |
| } |
| function isClientRequest(clientRequest) { |
| return is_1.default.object(clientRequest) && !('statusCode' in clientRequest); |
| } |
| const cacheableStore = new weakable_map_1.default(); |
| const waitForOpenFile = async (file) => new Promise((resolve, reject) => { |
| const onError = (error) => { |
| reject(error); |
| }; |
| // Node.js 12 has incomplete types |
| if (!file.pending) { |
| resolve(); |
| } |
| file.once('error', onError); |
| file.once('ready', () => { |
| file.off('error', onError); |
| resolve(); |
| }); |
| }); |
| const redirectCodes = new Set([300, 301, 302, 303, 304, 307, 308]); |
| const nonEnumerableProperties = [ |
| 'context', |
| 'body', |
| 'json', |
| 'form' |
| ]; |
| exports.setNonEnumerableProperties = (sources, to) => { |
| // Non enumerable properties shall not be merged |
| const properties = {}; |
| for (const source of sources) { |
| if (!source) { |
| continue; |
| } |
| for (const name of nonEnumerableProperties) { |
| if (!(name in source)) { |
| continue; |
| } |
| properties[name] = { |
| writable: true, |
| configurable: true, |
| enumerable: false, |
| // @ts-expect-error TS doesn't see the check above |
| value: source[name] |
| }; |
| } |
| } |
| Object.defineProperties(to, properties); |
| }; |
| /** |
| An error to be thrown when a request fails. |
| Contains a `code` property with error class code, like `ECONNREFUSED`. |
| */ |
| class RequestError extends Error { |
| constructor(message, error, self) { |
| var _a; |
| super(message); |
| Error.captureStackTrace(this, this.constructor); |
| this.name = 'RequestError'; |
| this.code = error.code; |
| if (self instanceof Request) { |
| Object.defineProperty(this, 'request', { |
| enumerable: false, |
| value: self |
| }); |
| Object.defineProperty(this, 'response', { |
| enumerable: false, |
| value: self[kResponse] |
| }); |
| Object.defineProperty(this, 'options', { |
| // This fails because of TS 3.7.2 useDefineForClassFields |
| // Ref: https://github.com/microsoft/TypeScript/issues/34972 |
| enumerable: false, |
| value: self.options |
| }); |
| } |
| else { |
| Object.defineProperty(this, 'options', { |
| // This fails because of TS 3.7.2 useDefineForClassFields |
| // Ref: https://github.com/microsoft/TypeScript/issues/34972 |
| enumerable: false, |
| value: self |
| }); |
| } |
| this.timings = (_a = this.request) === null || _a === void 0 ? void 0 : _a.timings; |
| // Recover the original stacktrace |
| if (is_1.default.string(error.stack) && is_1.default.string(this.stack)) { |
| const indexOfMessage = this.stack.indexOf(this.message) + this.message.length; |
| const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse(); |
| const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse(); |
| // Remove duplicated traces |
| while (errorStackTrace.length !== 0 && errorStackTrace[0] === thisStackTrace[0]) { |
| thisStackTrace.shift(); |
| } |
| this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`; |
| } |
| } |
| } |
| exports.RequestError = RequestError; |
| /** |
| An error to be thrown when the server redirects you more than ten times. |
| Includes a `response` property. |
| */ |
| class MaxRedirectsError extends RequestError { |
| constructor(request) { |
| super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request); |
| this.name = 'MaxRedirectsError'; |
| } |
| } |
| exports.MaxRedirectsError = MaxRedirectsError; |
| /** |
| An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304. |
| Includes a `response` property. |
| */ |
| class HTTPError extends RequestError { |
| constructor(response) { |
| super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request); |
| this.name = 'HTTPError'; |
| } |
| } |
| exports.HTTPError = HTTPError; |
| /** |
| An error to be thrown when a cache method fails. |
| For example, if the database goes down or there's a filesystem error. |
| */ |
| class CacheError extends RequestError { |
| constructor(error, request) { |
| super(error.message, error, request); |
| this.name = 'CacheError'; |
| } |
| } |
| exports.CacheError = CacheError; |
| /** |
| An error to be thrown when the request body is a stream and an error occurs while reading from that stream. |
| */ |
| class UploadError extends RequestError { |
| constructor(error, request) { |
| super(error.message, error, request); |
| this.name = 'UploadError'; |
| } |
| } |
| exports.UploadError = UploadError; |
| /** |
| An error to be thrown when the request is aborted due to a timeout. |
| Includes an `event` and `timings` property. |
| */ |
| class TimeoutError extends RequestError { |
| constructor(error, timings, request) { |
| super(error.message, error, request); |
| this.name = 'TimeoutError'; |
| this.event = error.event; |
| this.timings = timings; |
| } |
| } |
| exports.TimeoutError = TimeoutError; |
| /** |
| An error to be thrown when reading from response stream fails. |
| */ |
| class ReadError extends RequestError { |
| constructor(error, request) { |
| super(error.message, error, request); |
| this.name = 'ReadError'; |
| } |
| } |
| exports.ReadError = ReadError; |
| /** |
| An error to be thrown when given an unsupported protocol. |
| */ |
| class UnsupportedProtocolError extends RequestError { |
| constructor(options) { |
| super(`Unsupported protocol "${options.url.protocol}"`, {}, options); |
| this.name = 'UnsupportedProtocolError'; |
| } |
| } |
| exports.UnsupportedProtocolError = UnsupportedProtocolError; |
| const proxiedRequestEvents = [ |
| 'socket', |
| 'connect', |
| 'continue', |
| 'information', |
| 'upgrade', |
| 'timeout' |
| ]; |
| class Request extends stream_1.Duplex { |
| constructor(url, options = {}, defaults) { |
| super({ |
| // This must be false, to enable throwing after destroy |
| // It is used for retry logic in Promise API |
| autoDestroy: false, |
| // It needs to be zero because we're just proxying the data to another stream |
| highWaterMark: 0 |
| }); |
| this[kDownloadedSize] = 0; |
| this[kUploadedSize] = 0; |
| this.requestInitialized = false; |
| this[kServerResponsesPiped] = new Set(); |
| this.redirects = []; |
| this[kStopReading] = false; |
| this[kTriggerRead] = false; |
| this[kJobs] = []; |
| this.retryCount = 0; |
| // TODO: Remove this when targeting Node.js >= 12 |
| this._progressCallbacks = []; |
| const unlockWrite = () => this._unlockWrite(); |
| const lockWrite = () => this._lockWrite(); |
| this.on('pipe', (source) => { |
| source.prependListener('data', unlockWrite); |
| source.on('data', lockWrite); |
| source.prependListener('end', unlockWrite); |
| source.on('end', lockWrite); |
| }); |
| this.on('unpipe', (source) => { |
| source.off('data', unlockWrite); |
| source.off('data', lockWrite); |
| source.off('end', unlockWrite); |
| source.off('end', lockWrite); |
| }); |
| this.on('pipe', source => { |
| if (source instanceof http_1.IncomingMessage) { |
| this.options.headers = { |
| ...source.headers, |
| ...this.options.headers |
| }; |
| } |
| }); |
| const { json, body, form } = options; |
| if (json || body || form) { |
| this._lockWrite(); |
| } |
| if (exports.kIsNormalizedAlready in options) { |
| this.options = options; |
| } |
| else { |
| try { |
| // @ts-expect-error Common TypeScript bug saying that `this.constructor` is not accessible |
| this.options = this.constructor.normalizeArguments(url, options, defaults); |
| } |
| catch (error) { |
| // TODO: Move this to `_destroy()` |
| if (is_1.default.nodeStream(options.body)) { |
| options.body.destroy(); |
| } |
| this.destroy(error); |
| return; |
| } |
| } |
| (async () => { |
| var _a; |
| try { |
| if (this.options.body instanceof fs_1.ReadStream) { |
| await waitForOpenFile(this.options.body); |
| } |
| const { url: normalizedURL } = this.options; |
| if (!normalizedURL) { |
| throw new TypeError('Missing `url` property'); |
| } |
| this.requestUrl = normalizedURL.toString(); |
| decodeURI(this.requestUrl); |
| await this._finalizeBody(); |
| await this._makeRequest(); |
| if (this.destroyed) { |
| (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroy(); |
| return; |
| } |
| // Queued writes etc. |
| for (const job of this[kJobs]) { |
| job(); |
| } |
| // Prevent memory leak |
| this[kJobs].length = 0; |
| this.requestInitialized = true; |
| } |
| catch (error) { |
| if (error instanceof RequestError) { |
| this._beforeError(error); |
| return; |
| } |
| // This is a workaround for https://github.com/nodejs/node/issues/33335 |
| if (!this.destroyed) { |
| this.destroy(error); |
| } |
| } |
| })(); |
| } |
| static normalizeArguments(url, options, defaults) { |
| var _a, _b, _c, _d, _e; |
| const rawOptions = options; |
| if (is_1.default.object(url) && !is_1.default.urlInstance(url)) { |
| options = { ...defaults, ...url, ...options }; |
| } |
| else { |
| if (url && options && options.url !== undefined) { |
| throw new TypeError('The `url` option is mutually exclusive with the `input` argument'); |
| } |
| options = { ...defaults, ...options }; |
| if (url !== undefined) { |
| options.url = url; |
| } |
| if (is_1.default.urlInstance(options.url)) { |
| options.url = new url_1.URL(options.url.toString()); |
| } |
| } |
| // TODO: Deprecate URL options in Got 12. |
| // Support extend-specific options |
| if (options.cache === false) { |
| options.cache = undefined; |
| } |
| if (options.dnsCache === false) { |
| options.dnsCache = undefined; |
| } |
| // Nice type assertions |
| is_1.assert.any([is_1.default.string, is_1.default.undefined], options.method); |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.headers); |
| is_1.assert.any([is_1.default.string, is_1.default.urlInstance, is_1.default.undefined], options.prefixUrl); |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cookieJar); |
| is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.searchParams); |
| is_1.assert.any([is_1.default.object, is_1.default.string, is_1.default.undefined], options.cache); |
| is_1.assert.any([is_1.default.object, is_1.default.number, is_1.default.undefined], options.timeout); |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.context); |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.hooks); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.decompress); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.ignoreInvalidCookies); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.followRedirect); |
| is_1.assert.any([is_1.default.number, is_1.default.undefined], options.maxRedirects); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.throwHttpErrors); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.http2); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.allowGetBody); |
| is_1.assert.any([is_1.default.string, is_1.default.undefined], options.localAddress); |
| is_1.assert.any([dns_ip_version_1.isDnsLookupIpVersion, is_1.default.undefined], options.dnsLookupIpVersion); |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.https); |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.rejectUnauthorized); |
| if (options.https) { |
| is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.https.rejectUnauthorized); |
| is_1.assert.any([is_1.default.function_, is_1.default.undefined], options.https.checkServerIdentity); |
| is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificateAuthority); |
| is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.key); |
| is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificate); |
| is_1.assert.any([is_1.default.string, is_1.default.undefined], options.https.passphrase); |
| is_1.assert.any([is_1.default.string, is_1.default.buffer, is_1.default.array, is_1.default.undefined], options.https.pfx); |
| } |
| is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cacheOptions); |
| // `options.method` |
| if (is_1.default.string(options.method)) { |
| options.method = options.method.toUpperCase(); |
| } |
| else { |
| options.method = 'GET'; |
| } |
| // `options.headers` |
| if (options.headers === (defaults === null || defaults === void 0 ? void 0 : defaults.headers)) { |
| options.headers = { ...options.headers }; |
| } |
| else { |
| options.headers = lowercaseKeys({ ...(defaults === null || defaults === void 0 ? void 0 : defaults.headers), ...options.headers }); |
| } |
| // Disallow legacy `url.Url` |
| if ('slashes' in options) { |
| throw new TypeError('The legacy `url.Url` has been deprecated. Use `URL` instead.'); |
| } |
| // `options.auth` |
| if ('auth' in options) { |
| throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.'); |
| } |
| // `options.searchParams` |
| if ('searchParams' in options) { |
| if (options.searchParams && options.searchParams !== (defaults === null || defaults === void 0 ? void 0 : defaults.searchParams)) { |
| let searchParameters; |
| if (is_1.default.string(options.searchParams) || (options.searchParams instanceof url_1.URLSearchParams)) { |
| searchParameters = new url_1.URLSearchParams(options.searchParams); |
| } |
| else { |
| validateSearchParameters(options.searchParams); |
| searchParameters = new url_1.URLSearchParams(); |
| // eslint-disable-next-line guard-for-in |
| for (const key in options.searchParams) { |
| const value = options.searchParams[key]; |
| if (value === null) { |
| searchParameters.append(key, ''); |
| } |
| else if (value !== undefined) { |
| searchParameters.append(key, value); |
| } |
| } |
| } |
| // `normalizeArguments()` is also used to merge options |
| (_a = defaults === null || defaults === void 0 ? void 0 : defaults.searchParams) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => { |
| // Only use default if one isn't already defined |
| if (!searchParameters.has(key)) { |
| searchParameters.append(key, value); |
| } |
| }); |
| options.searchParams = searchParameters; |
| } |
| } |
| // `options.username` & `options.password` |
| options.username = (_b = options.username) !== null && _b !== void 0 ? _b : ''; |
| options.password = (_c = options.password) !== null && _c !== void 0 ? _c : ''; |
| // `options.prefixUrl` & `options.url` |
| if (is_1.default.undefined(options.prefixUrl)) { |
| options.prefixUrl = (_d = defaults === null || defaults === void 0 ? void 0 : defaults.prefixUrl) !== null && _d !== void 0 ? _d : ''; |
| } |
| else { |
| options.prefixUrl = options.prefixUrl.toString(); |
| if (options.prefixUrl !== '' && !options.prefixUrl.endsWith('/')) { |
| options.prefixUrl += '/'; |
| } |
| } |
| if (is_1.default.string(options.url)) { |
| if (options.url.startsWith('/')) { |
| throw new Error('`input` must not start with a slash when using `prefixUrl`'); |
| } |
| options.url = options_to_url_1.default(options.prefixUrl + options.url, options); |
| } |
| else if ((is_1.default.undefined(options.url) && options.prefixUrl !== '') || options.protocol) { |
| options.url = options_to_url_1.default(options.prefixUrl, options); |
| } |
| if (options.url) { |
| if ('port' in options) { |
| delete options.port; |
| } |
| // Make it possible to change `options.prefixUrl` |
| let { prefixUrl } = options; |
| Object.defineProperty(options, 'prefixUrl', { |
| set: (value) => { |
| const url = options.url; |
| if (!url.href.startsWith(value)) { |
| throw new Error(`Cannot change \`prefixUrl\` from ${prefixUrl} to ${value}: ${url.href}`); |
| } |
| options.url = new url_1.URL(value + url.href.slice(prefixUrl.length)); |
| prefixUrl = value; |
| }, |
| get: () => prefixUrl |
| }); |
| // Support UNIX sockets |
| let { protocol } = options.url; |
| if (protocol === 'unix:') { |
| protocol = 'http:'; |
| options.url = new url_1.URL(`http://unix${options.url.pathname}${options.url.search}`); |
| } |
| // Set search params |
| if (options.searchParams) { |
| // eslint-disable-next-line @typescript-eslint/no-base-to-string |
| options.url.search = options.searchParams.toString(); |
| } |
| // Protocol check |
| if (protocol !== 'http:' && protocol !== 'https:') { |
| throw new UnsupportedProtocolError(options); |
| } |
| // Update `username` |
| if (options.username === '') { |
| options.username = options.url.username; |
| } |
| else { |
| options.url.username = options.username; |
| } |
| // Update `password` |
| if (options.password === '') { |
| options.password = options.url.password; |
| } |
| else { |
| options.url.password = options.password; |
| } |
| } |
| // `options.cookieJar` |
| const { cookieJar } = options; |
| if (cookieJar) { |
| let { setCookie, getCookieString } = cookieJar; |
| is_1.assert.function_(setCookie); |
| is_1.assert.function_(getCookieString); |
| /* istanbul ignore next: Horrible `tough-cookie` v3 check */ |
| if (setCookie.length === 4 && getCookieString.length === 0) { |
| setCookie = util_1.promisify(setCookie.bind(options.cookieJar)); |
| getCookieString = util_1.promisify(getCookieString.bind(options.cookieJar)); |
| options.cookieJar = { |
| setCookie, |
| getCookieString: getCookieString |
| }; |
| } |
| } |
| // `options.cache` |
| const { cache } = options; |
| if (cache) { |
| if (!cacheableStore.has(cache)) { |
| cacheableStore.set(cache, new CacheableRequest(((requestOptions, handler) => { |
| const result = requestOptions[kRequest](requestOptions, handler); |
| // TODO: remove this when `cacheable-request` supports async request functions. |
| if (is_1.default.promise(result)) { |
| // @ts-expect-error |
| // We only need to implement the error handler in order to support HTTP2 caching. |
| // The result will be a promise anyway. |
| result.once = (event, handler) => { |
| if (event === 'error') { |
| result.catch(handler); |
| } |
| else if (event === 'abort') { |
| // The empty catch is needed here in case when |
| // it rejects before it's `await`ed in `_makeRequest`. |
| (async () => { |
| try { |
| const request = (await result); |
| request.once('abort', handler); |
| } |
| catch (_a) { } |
| })(); |
| } |
| else { |
| /* istanbul ignore next: safety check */ |
| throw new Error(`Unknown HTTP2 promise event: ${event}`); |
| } |
| return result; |
| }; |
| } |
| return result; |
| }), cache)); |
| } |
| } |
| // `options.cacheOptions` |
| options.cacheOptions = { ...options.cacheOptions }; |
| // `options.dnsCache` |
| if (options.dnsCache === true) { |
| if (!globalDnsCache) { |
| globalDnsCache = new cacheable_lookup_1.default(); |
| } |
| options.dnsCache = globalDnsCache; |
| } |
| else if (!is_1.default.undefined(options.dnsCache) && !options.dnsCache.lookup) { |
| throw new TypeError(`Parameter \`dnsCache\` must be a CacheableLookup instance or a boolean, got ${is_1.default(options.dnsCache)}`); |
| } |
| // `options.timeout` |
| if (is_1.default.number(options.timeout)) { |
| options.timeout = { request: options.timeout }; |
| } |
| else if (defaults && options.timeout !== defaults.timeout) { |
| options.timeout = { |
| ...defaults.timeout, |
| ...options.timeout |
| }; |
| } |
| else { |
| options.timeout = { ...options.timeout }; |
| } |
| // `options.context` |
| if (!options.context) { |
| options.context = {}; |
| } |
| // `options.hooks` |
| const areHooksDefault = options.hooks === (defaults === null || defaults === void 0 ? void 0 : defaults.hooks); |
| options.hooks = { ...options.hooks }; |
| for (const event of exports.knownHookEvents) { |
| if (event in options.hooks) { |
| if (is_1.default.array(options.hooks[event])) { |
| // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044 |
| options.hooks[event] = [...options.hooks[event]]; |
| } |
| else { |
| throw new TypeError(`Parameter \`${event}\` must be an Array, got ${is_1.default(options.hooks[event])}`); |
| } |
| } |
| else { |
| options.hooks[event] = []; |
| } |
| } |
| if (defaults && !areHooksDefault) { |
| for (const event of exports.knownHookEvents) { |
| const defaultHooks = defaults.hooks[event]; |
| if (defaultHooks.length > 0) { |
| // See https://github.com/microsoft/TypeScript/issues/31445#issuecomment-576929044 |
| options.hooks[event] = [ |
| ...defaults.hooks[event], |
| ...options.hooks[event] |
| ]; |
| } |
| } |
| } |
| // DNS options |
| if ('family' in options) { |
| deprecation_warning_1.default('"options.family" was never documented, please use "options.dnsLookupIpVersion"'); |
| } |
| // HTTPS options |
| if (defaults === null || defaults === void 0 ? void 0 : defaults.https) { |
| options.https = { ...defaults.https, ...options.https }; |
| } |
| if ('rejectUnauthorized' in options) { |
| deprecation_warning_1.default('"options.rejectUnauthorized" is now deprecated, please use "options.https.rejectUnauthorized"'); |
| } |
| if ('checkServerIdentity' in options) { |
| deprecation_warning_1.default('"options.checkServerIdentity" was never documented, please use "options.https.checkServerIdentity"'); |
| } |
| if ('ca' in options) { |
| deprecation_warning_1.default('"options.ca" was never documented, please use "options.https.certificateAuthority"'); |
| } |
| if ('key' in options) { |
| deprecation_warning_1.default('"options.key" was never documented, please use "options.https.key"'); |
| } |
| if ('cert' in options) { |
| deprecation_warning_1.default('"options.cert" was never documented, please use "options.https.certificate"'); |
| } |
| if ('passphrase' in options) { |
| deprecation_warning_1.default('"options.passphrase" was never documented, please use "options.https.passphrase"'); |
| } |
| if ('pfx' in options) { |
| deprecation_warning_1.default('"options.pfx" was never documented, please use "options.https.pfx"'); |
| } |
| // Other options |
| if ('followRedirects' in options) { |
| throw new TypeError('The `followRedirects` option does not exist. Use `followRedirect` instead.'); |
| } |
| if (options.agent) { |
| for (const key in options.agent) { |
| if (key !== 'http' && key !== 'https' && key !== 'http2') { |
| throw new TypeError(`Expected the \`options.agent\` properties to be \`http\`, \`https\` or \`http2\`, got \`${key}\``); |
| } |
| } |
| } |
| options.maxRedirects = (_e = options.maxRedirects) !== null && _e !== void 0 ? _e : 0; |
| // Set non-enumerable properties |
| exports.setNonEnumerableProperties([defaults, rawOptions], options); |
| return normalize_arguments_1.default(options, defaults); |
| } |
| _lockWrite() { |
| const onLockedWrite = () => { |
| throw new TypeError('The payload has been already provided'); |
| }; |
| this.write = onLockedWrite; |
| this.end = onLockedWrite; |
| } |
| _unlockWrite() { |
| this.write = super.write; |
| this.end = super.end; |
| } |
| async _finalizeBody() { |
| const { options } = this; |
| const { headers } = options; |
| const isForm = !is_1.default.undefined(options.form); |
| const isJSON = !is_1.default.undefined(options.json); |
| const isBody = !is_1.default.undefined(options.body); |
| const hasPayload = isForm || isJSON || isBody; |
| const cannotHaveBody = exports.withoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody); |
| this._cannotHaveBody = cannotHaveBody; |
| if (hasPayload) { |
| if (cannotHaveBody) { |
| throw new TypeError(`The \`${options.method}\` method cannot be used with a body`); |
| } |
| if ([isBody, isForm, isJSON].filter(isTrue => isTrue).length > 1) { |
| throw new TypeError('The `body`, `json` and `form` options are mutually exclusive'); |
| } |
| if (isBody && |
| !(options.body instanceof stream_1.Readable) && |
| !is_1.default.string(options.body) && |
| !is_1.default.buffer(options.body) && |
| !is_form_data_1.default(options.body)) { |
| throw new TypeError('The `body` option must be a stream.Readable, string or Buffer'); |
| } |
| if (isForm && !is_1.default.object(options.form)) { |
| throw new TypeError('The `form` option must be an Object'); |
| } |
| { |
| // Serialize body |
| const noContentType = !is_1.default.string(headers['content-type']); |
| if (isBody) { |
| // Special case for https://github.com/form-data/form-data |
| if (is_form_data_1.default(options.body) && noContentType) { |
| headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`; |
| } |
| this[kBody] = options.body; |
| } |
| else if (isForm) { |
| if (noContentType) { |
| headers['content-type'] = 'application/x-www-form-urlencoded'; |
| } |
| this[kBody] = (new url_1.URLSearchParams(options.form)).toString(); |
| } |
| else { |
| if (noContentType) { |
| headers['content-type'] = 'application/json'; |
| } |
| this[kBody] = options.stringifyJson(options.json); |
| } |
| const uploadBodySize = await get_body_size_1.default(this[kBody], options.headers); |
| // See https://tools.ietf.org/html/rfc7230#section-3.3.2 |
| // A user agent SHOULD send a Content-Length in a request message when |
| // no Transfer-Encoding is sent and the request method defines a meaning |
| // for an enclosed payload body. For example, a Content-Length header |
| // field is normally sent in a POST request even when the value is 0 |
| // (indicating an empty payload body). A user agent SHOULD NOT send a |
| // Content-Length header field when the request message does not contain |
| // a payload body and the method semantics do not anticipate such a |
| // body. |
| if (is_1.default.undefined(headers['content-length']) && is_1.default.undefined(headers['transfer-encoding'])) { |
| if (!cannotHaveBody && !is_1.default.undefined(uploadBodySize)) { |
| headers['content-length'] = String(uploadBodySize); |
| } |
| } |
| } |
| } |
| else if (cannotHaveBody) { |
| this._lockWrite(); |
| } |
| else { |
| this._unlockWrite(); |
| } |
| this[kBodySize] = Number(headers['content-length']) || undefined; |
| } |
| async _onResponseBase(response) { |
| const { options } = this; |
| const { url } = options; |
| this[kOriginalResponse] = response; |
| if (options.decompress) { |
| response = decompressResponse(response); |
| } |
| const statusCode = response.statusCode; |
| const typedResponse = response; |
| typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode]; |
| typedResponse.url = options.url.toString(); |
| typedResponse.requestUrl = this.requestUrl; |
| typedResponse.redirectUrls = this.redirects; |
| typedResponse.request = this; |
| typedResponse.isFromCache = response.fromCache || false; |
| typedResponse.ip = this.ip; |
| typedResponse.retryCount = this.retryCount; |
| this[kIsFromCache] = typedResponse.isFromCache; |
| this[kResponseSize] = Number(response.headers['content-length']) || undefined; |
| this[kResponse] = response; |
| response.once('end', () => { |
| this[kResponseSize] = this[kDownloadedSize]; |
| this.emit('downloadProgress', this.downloadProgress); |
| }); |
| response.once('error', (error) => { |
| // Force clean-up, because some packages don't do this. |
| // TODO: Fix decompress-response |
| response.destroy(); |
| this._beforeError(new ReadError(error, this)); |
| }); |
| response.once('aborted', () => { |
| this._beforeError(new ReadError({ |
| name: 'Error', |
| message: 'The server aborted pending request', |
| code: 'ECONNRESET' |
| }, this)); |
| }); |
| this.emit('downloadProgress', this.downloadProgress); |
| const rawCookies = response.headers['set-cookie']; |
| if (is_1.default.object(options.cookieJar) && rawCookies) { |
| let promises = rawCookies.map(async (rawCookie) => options.cookieJar.setCookie(rawCookie, url.toString())); |
| if (options.ignoreInvalidCookies) { |
| promises = promises.map(async (p) => p.catch(() => { })); |
| } |
| try { |
| await Promise.all(promises); |
| } |
| catch (error) { |
| this._beforeError(error); |
| return; |
| } |
| } |
| if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) { |
| // We're being redirected, we don't care about the response. |
| // It'd be best to abort the request, but we can't because |
| // we would have to sacrifice the TCP connection. We don't want that. |
| response.resume(); |
| if (this[kRequest]) { |
| this[kCancelTimeouts](); |
| // eslint-disable-next-line @typescript-eslint/no-dynamic-delete |
| delete this[kRequest]; |
| this[kUnproxyEvents](); |
| } |
| const shouldBeGet = statusCode === 303 && options.method !== 'GET' && options.method !== 'HEAD'; |
| if (shouldBeGet || !options.methodRewriting) { |
| // Server responded with "see other", indicating that the resource exists at another location, |
| // and the client should request it from that location via GET or HEAD. |
| options.method = 'GET'; |
| if ('body' in options) { |
| delete options.body; |
| } |
| if ('json' in options) { |
| delete options.json; |
| } |
| if ('form' in options) { |
| delete options.form; |
| } |
| this[kBody] = undefined; |
| delete options.headers['content-length']; |
| } |
| if (this.redirects.length >= options.maxRedirects) { |
| this._beforeError(new MaxRedirectsError(this)); |
| return; |
| } |
| try { |
| // Do not remove. See https://github.com/sindresorhus/got/pull/214 |
| const redirectBuffer = Buffer.from(response.headers.location, 'binary').toString(); |
| // Handles invalid URLs. See https://github.com/sindresorhus/got/issues/604 |
| const redirectUrl = new url_1.URL(redirectBuffer, url); |
| const redirectString = redirectUrl.toString(); |
| decodeURI(redirectString); |
| // Redirecting to a different site, clear sensitive data. |
| if (redirectUrl.hostname !== url.hostname || redirectUrl.port !== url.port) { |
| if ('host' in options.headers) { |
| delete options.headers.host; |
| } |
| if ('cookie' in options.headers) { |
| delete options.headers.cookie; |
| } |
| if ('authorization' in options.headers) { |
| delete options.headers.authorization; |
| } |
| if (options.username || options.password) { |
| options.username = ''; |
| options.password = ''; |
| } |
| } |
| else { |
| redirectUrl.username = options.username; |
| redirectUrl.password = options.password; |
| } |
| this.redirects.push(redirectString); |
| options.url = redirectUrl; |
| for (const hook of options.hooks.beforeRedirect) { |
| // eslint-disable-next-line no-await-in-loop |
| await hook(options, typedResponse); |
| } |
| this.emit('redirect', typedResponse, options); |
| await this._makeRequest(); |
| } |
| catch (error) { |
| this._beforeError(error); |
| return; |
| } |
| return; |
| } |
| if (options.isStream && options.throwHttpErrors && !is_response_ok_1.isResponseOk(typedResponse)) { |
| this._beforeError(new HTTPError(typedResponse)); |
| return; |
| } |
| response.on('readable', () => { |
| if (this[kTriggerRead]) { |
| this._read(); |
| } |
| }); |
| this.on('resume', () => { |
| response.resume(); |
| }); |
| this.on('pause', () => { |
| response.pause(); |
| }); |
| response.once('end', () => { |
| this.push(null); |
| }); |
| this.emit('response', response); |
| for (const destination of this[kServerResponsesPiped]) { |
| if (destination.headersSent) { |
| continue; |
| } |
| // eslint-disable-next-line guard-for-in |
| for (const key in response.headers) { |
| const isAllowed = options.decompress ? key !== 'content-encoding' : true; |
| const value = response.headers[key]; |
| if (isAllowed) { |
| destination.setHeader(key, value); |
| } |
| } |
| destination.statusCode = statusCode; |
| } |
| } |
| async _onResponse(response) { |
| try { |
| await this._onResponseBase(response); |
| } |
| catch (error) { |
| /* istanbul ignore next: better safe than sorry */ |
| this._beforeError(error); |
| } |
| } |
| _onRequest(request) { |
| const { options } = this; |
| const { timeout, url } = options; |
| http_timer_1.default(request); |
| this[kCancelTimeouts] = timed_out_1.default(request, timeout, url); |
| const responseEventName = options.cache ? 'cacheableResponse' : 'response'; |
| request.once(responseEventName, (response) => { |
| void this._onResponse(response); |
| }); |
| request.once('error', (error) => { |
| var _a; |
| // Force clean-up, because some packages (e.g. nock) don't do this. |
| request.destroy(); |
| // Node.js <= 12.18.2 mistakenly emits the response `end` first. |
| (_a = request.res) === null || _a === void 0 ? void 0 : _a.removeAllListeners('end'); |
| error = error instanceof timed_out_1.TimeoutError ? new TimeoutError(error, this.timings, this) : new RequestError(error.message, error, this); |
| this._beforeError(error); |
| }); |
| this[kUnproxyEvents] = proxy_events_1.default(request, this, proxiedRequestEvents); |
| this[kRequest] = request; |
| this.emit('uploadProgress', this.uploadProgress); |
| // Send body |
| const body = this[kBody]; |
| const currentRequest = this.redirects.length === 0 ? this : request; |
| if (is_1.default.nodeStream(body)) { |
| body.pipe(currentRequest); |
| body.once('error', (error) => { |
| this._beforeError(new UploadError(error, this)); |
| }); |
| } |
| else { |
| this._unlockWrite(); |
| if (!is_1.default.undefined(body)) { |
| this._writeRequest(body, undefined, () => { }); |
| currentRequest.end(); |
| this._lockWrite(); |
| } |
| else if (this._cannotHaveBody || this._noPipe) { |
| currentRequest.end(); |
| this._lockWrite(); |
| } |
| } |
| this.emit('request', request); |
| } |
| async _createCacheableRequest(url, options) { |
| return new Promise((resolve, reject) => { |
| // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed |
| Object.assign(options, url_to_options_1.default(url)); |
| // `http-cache-semantics` checks this |
| // TODO: Fix this ignore. |
| // @ts-expect-error |
| delete options.url; |
| let request; |
| // This is ugly |
| const cacheRequest = cacheableStore.get(options.cache)(options, async (response) => { |
| // TODO: Fix `cacheable-response` |
| response._readableState.autoDestroy = false; |
| if (request) { |
| (await request).emit('cacheableResponse', response); |
| } |
| resolve(response); |
| }); |
| // Restore options |
| options.url = url; |
| cacheRequest.once('error', reject); |
| cacheRequest.once('request', async (requestOrPromise) => { |
| request = requestOrPromise; |
| resolve(request); |
| }); |
| }); |
| } |
| async _makeRequest() { |
| var _a, _b, _c, _d, _e; |
| const { options } = this; |
| const { headers } = options; |
| for (const key in headers) { |
| if (is_1.default.undefined(headers[key])) { |
| // eslint-disable-next-line @typescript-eslint/no-dynamic-delete |
| delete headers[key]; |
| } |
| else if (is_1.default.null_(headers[key])) { |
| throw new TypeError(`Use \`undefined\` instead of \`null\` to delete the \`${key}\` header`); |
| } |
| } |
| if (options.decompress && is_1.default.undefined(headers['accept-encoding'])) { |
| headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate'; |
| } |
| // Set cookies |
| if (options.cookieJar) { |
| const cookieString = await options.cookieJar.getCookieString(options.url.toString()); |
| if (is_1.default.nonEmptyString(cookieString)) { |
| options.headers.cookie = cookieString; |
| } |
| } |
| for (const hook of options.hooks.beforeRequest) { |
| // eslint-disable-next-line no-await-in-loop |
| const result = await hook(options); |
| if (!is_1.default.undefined(result)) { |
| // @ts-expect-error Skip the type mismatch to support abstract responses |
| options.request = () => result; |
| break; |
| } |
| } |
| if (options.body && this[kBody] !== options.body) { |
| this[kBody] = options.body; |
| } |
| const { agent, request, timeout, url } = options; |
| if (options.dnsCache && !('lookup' in options)) { |
| options.lookup = options.dnsCache.lookup; |
| } |
| // UNIX sockets |
| if (url.hostname === 'unix') { |
| const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`); |
| if (matches === null || matches === void 0 ? void 0 : matches.groups) { |
| const { socketPath, path } = matches.groups; |
| Object.assign(options, { |
| socketPath, |
| path, |
| host: '' |
| }); |
| } |
| } |
| const isHttps = url.protocol === 'https:'; |
| // Fallback function |
| let fallbackFn; |
| if (options.http2) { |
| fallbackFn = http2wrapper.auto; |
| } |
| else { |
| fallbackFn = isHttps ? https.request : http.request; |
| } |
| const realFn = (_a = options.request) !== null && _a !== void 0 ? _a : fallbackFn; |
| // Cache support |
| const fn = options.cache ? this._createCacheableRequest : realFn; |
| // Pass an agent directly when HTTP2 is disabled |
| if (agent && !options.http2) { |
| options.agent = agent[isHttps ? 'https' : 'http']; |
| } |
| // Prepare plain HTTP request options |
| options[kRequest] = realFn; |
| delete options.request; |
| // TODO: Fix this ignore. |
| // @ts-expect-error |
| delete options.timeout; |
| const requestOptions = options; |
| requestOptions.shared = (_b = options.cacheOptions) === null || _b === void 0 ? void 0 : _b.shared; |
| requestOptions.cacheHeuristic = (_c = options.cacheOptions) === null || _c === void 0 ? void 0 : _c.cacheHeuristic; |
| requestOptions.immutableMinTimeToLive = (_d = options.cacheOptions) === null || _d === void 0 ? void 0 : _d.immutableMinTimeToLive; |
| requestOptions.ignoreCargoCult = (_e = options.cacheOptions) === null || _e === void 0 ? void 0 : _e.ignoreCargoCult; |
| // If `dnsLookupIpVersion` is not present do not override `family` |
| if (options.dnsLookupIpVersion !== undefined) { |
| try { |
| requestOptions.family = dns_ip_version_1.dnsLookupIpVersionToFamily(options.dnsLookupIpVersion); |
| } |
| catch (_f) { |
| throw new Error('Invalid `dnsLookupIpVersion` option value'); |
| } |
| } |
| // HTTPS options remapping |
| if (options.https) { |
| if ('rejectUnauthorized' in options.https) { |
| requestOptions.rejectUnauthorized = options.https.rejectUnauthorized; |
| } |
| if (options.https.checkServerIdentity) { |
| requestOptions.checkServerIdentity = options.https.checkServerIdentity; |
| } |
| if (options.https.certificateAuthority) { |
| requestOptions.ca = options.https.certificateAuthority; |
| } |
| if (options.https.certificate) { |
| requestOptions.cert = options.https.certificate; |
| } |
| if (options.https.key) { |
| requestOptions.key = options.https.key; |
| } |
| if (options.https.passphrase) { |
| requestOptions.passphrase = options.https.passphrase; |
| } |
| if (options.https.pfx) { |
| requestOptions.pfx = options.https.pfx; |
| } |
| } |
| try { |
| let requestOrResponse = await fn(url, requestOptions); |
| if (is_1.default.undefined(requestOrResponse)) { |
| requestOrResponse = fallbackFn(url, requestOptions); |
| } |
| // Restore options |
| options.request = request; |
| options.timeout = timeout; |
| options.agent = agent; |
| // HTTPS options restore |
| if (options.https) { |
| if ('rejectUnauthorized' in options.https) { |
| delete requestOptions.rejectUnauthorized; |
| } |
| if (options.https.checkServerIdentity) { |
| // @ts-expect-error - This one will be removed when we remove the alias. |
| delete requestOptions.checkServerIdentity; |
| } |
| if (options.https.certificateAuthority) { |
| delete requestOptions.ca; |
| } |
| if (options.https.certificate) { |
| delete requestOptions.cert; |
| } |
| if (options.https.key) { |
| delete requestOptions.key; |
| } |
| if (options.https.passphrase) { |
| delete requestOptions.passphrase; |
| } |
| if (options.https.pfx) { |
| delete requestOptions.pfx; |
| } |
| } |
| if (isClientRequest(requestOrResponse)) { |
| this._onRequest(requestOrResponse); |
| // Emit the response after the stream has been ended |
| } |
| else if (this.writable) { |
| this.once('finish', () => { |
| void this._onResponse(requestOrResponse); |
| }); |
| this._unlockWrite(); |
| this.end(); |
| this._lockWrite(); |
| } |
| else { |
| void this._onResponse(requestOrResponse); |
| } |
| } |
| catch (error) { |
| if (error instanceof CacheableRequest.CacheError) { |
| throw new CacheError(error, this); |
| } |
| throw new RequestError(error.message, error, this); |
| } |
| } |
| async _error(error) { |
| try { |
| for (const hook of this.options.hooks.beforeError) { |
| // eslint-disable-next-line no-await-in-loop |
| error = await hook(error); |
| } |
| } |
| catch (error_) { |
| error = new RequestError(error_.message, error_, this); |
| } |
| this.destroy(error); |
| } |
| _beforeError(error) { |
| if (this[kStopReading]) { |
| return; |
| } |
| const { options } = this; |
| const retryCount = this.retryCount + 1; |
| this[kStopReading] = true; |
| if (!(error instanceof RequestError)) { |
| error = new RequestError(error.message, error, this); |
| } |
| const typedError = error; |
| const { response } = typedError; |
| void (async () => { |
| if (response && !response.body) { |
| response.setEncoding(this._readableState.encoding); |
| try { |
| response.rawBody = await get_buffer_1.default(response); |
| response.body = response.rawBody.toString(); |
| } |
| catch (_a) { } |
| } |
| if (this.listenerCount('retry') !== 0) { |
| let backoff; |
| try { |
| let retryAfter; |
| if (response && 'retry-after' in response.headers) { |
| retryAfter = Number(response.headers['retry-after']); |
| if (Number.isNaN(retryAfter)) { |
| retryAfter = Date.parse(response.headers['retry-after']) - Date.now(); |
| if (retryAfter <= 0) { |
| retryAfter = 1; |
| } |
| } |
| else { |
| retryAfter *= 1000; |
| } |
| } |
| backoff = await options.retry.calculateDelay({ |
| attemptCount: retryCount, |
| retryOptions: options.retry, |
| error: typedError, |
| retryAfter, |
| computedValue: calculate_retry_delay_1.default({ |
| attemptCount: retryCount, |
| retryOptions: options.retry, |
| error: typedError, |
| retryAfter, |
| computedValue: 0 |
| }) |
| }); |
| } |
| catch (error_) { |
| void this._error(new RequestError(error_.message, error_, this)); |
| return; |
| } |
| if (backoff) { |
| const retry = async () => { |
| try { |
| for (const hook of this.options.hooks.beforeRetry) { |
| // eslint-disable-next-line no-await-in-loop |
| await hook(this.options, typedError, retryCount); |
| } |
| } |
| catch (error_) { |
| void this._error(new RequestError(error_.message, error, this)); |
| return; |
| } |
| // Something forced us to abort the retry |
| if (this.destroyed) { |
| return; |
| } |
| this.destroy(); |
| this.emit('retry', retryCount, error); |
| }; |
| this[kRetryTimeout] = setTimeout(retry, backoff); |
| return; |
| } |
| } |
| void this._error(typedError); |
| })(); |
| } |
| _read() { |
| this[kTriggerRead] = true; |
| const response = this[kResponse]; |
| if (response && !this[kStopReading]) { |
| // We cannot put this in the `if` above |
| // because `.read()` also triggers the `end` event |
| if (response.readableLength) { |
| this[kTriggerRead] = false; |
| } |
| let data; |
| while ((data = response.read()) !== null) { |
| this[kDownloadedSize] += data.length; |
| this[kStartedReading] = true; |
| const progress = this.downloadProgress; |
| if (progress.percent < 1) { |
| this.emit('downloadProgress', progress); |
| } |
| this.push(data); |
| } |
| } |
| } |
| // Node.js 12 has incorrect types, so the encoding must be a string |
| _write(chunk, encoding, callback) { |
| const write = () => { |
| this._writeRequest(chunk, encoding, callback); |
| }; |
| if (this.requestInitialized) { |
| write(); |
| } |
| else { |
| this[kJobs].push(write); |
| } |
| } |
| _writeRequest(chunk, encoding, callback) { |
| if (this[kRequest].destroyed) { |
| // Probably the `ClientRequest` instance will throw |
| return; |
| } |
| this._progressCallbacks.push(() => { |
| this[kUploadedSize] += Buffer.byteLength(chunk, encoding); |
| const progress = this.uploadProgress; |
| if (progress.percent < 1) { |
| this.emit('uploadProgress', progress); |
| } |
| }); |
| // TODO: What happens if it's from cache? Then this[kRequest] won't be defined. |
| this[kRequest].write(chunk, encoding, (error) => { |
| if (!error && this._progressCallbacks.length > 0) { |
| this._progressCallbacks.shift()(); |
| } |
| callback(error); |
| }); |
| } |
| _final(callback) { |
| const endRequest = () => { |
| // FIX: Node.js 10 calls the write callback AFTER the end callback! |
| while (this._progressCallbacks.length !== 0) { |
| this._progressCallbacks.shift()(); |
| } |
| // We need to check if `this[kRequest]` is present, |
| // because it isn't when we use cache. |
| if (!(kRequest in this)) { |
| callback(); |
| return; |
| } |
| if (this[kRequest].destroyed) { |
| callback(); |
| return; |
| } |
| this[kRequest].end((error) => { |
| if (!error) { |
| this[kBodySize] = this[kUploadedSize]; |
| this.emit('uploadProgress', this.uploadProgress); |
| this[kRequest].emit('upload-complete'); |
| } |
| callback(error); |
| }); |
| }; |
| if (this.requestInitialized) { |
| endRequest(); |
| } |
| else { |
| this[kJobs].push(endRequest); |
| } |
| } |
| _destroy(error, callback) { |
| var _a; |
| this[kStopReading] = true; |
| // Prevent further retries |
| clearTimeout(this[kRetryTimeout]); |
| if (kRequest in this) { |
| this[kCancelTimeouts](); |
| // TODO: Remove the next `if` when these get fixed: |
| // - https://github.com/nodejs/node/issues/32851 |
| if (!((_a = this[kResponse]) === null || _a === void 0 ? void 0 : _a.complete)) { |
| this[kRequest].destroy(); |
| } |
| } |
| if (error !== null && !is_1.default.undefined(error) && !(error instanceof RequestError)) { |
| error = new RequestError(error.message, error, this); |
| } |
| callback(error); |
| } |
| get _isAboutToError() { |
| return this[kStopReading]; |
| } |
| /** |
| The remote IP address. |
| */ |
| get ip() { |
| var _a; |
| return (_a = this.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress; |
| } |
| /** |
| Indicates whether the request has been aborted or not. |
| */ |
| get aborted() { |
| var _a, _b, _c; |
| return ((_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroyed) !== null && _b !== void 0 ? _b : this.destroyed) && !((_c = this[kOriginalResponse]) === null || _c === void 0 ? void 0 : _c.complete); |
| } |
| get socket() { |
| var _a, _b; |
| return (_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket) !== null && _b !== void 0 ? _b : undefined; |
| } |
| /** |
| Progress event for downloading (receiving a response). |
| */ |
| get downloadProgress() { |
| let percent; |
| if (this[kResponseSize]) { |
| percent = this[kDownloadedSize] / this[kResponseSize]; |
| } |
| else if (this[kResponseSize] === this[kDownloadedSize]) { |
| percent = 1; |
| } |
| else { |
| percent = 0; |
| } |
| return { |
| percent, |
| transferred: this[kDownloadedSize], |
| total: this[kResponseSize] |
| }; |
| } |
| /** |
| Progress event for uploading (sending a request). |
| */ |
| get uploadProgress() { |
| let percent; |
| if (this[kBodySize]) { |
| percent = this[kUploadedSize] / this[kBodySize]; |
| } |
| else if (this[kBodySize] === this[kUploadedSize]) { |
| percent = 1; |
| } |
| else { |
| percent = 0; |
| } |
| return { |
| percent, |
| transferred: this[kUploadedSize], |
| total: this[kBodySize] |
| }; |
| } |
| /** |
| The object contains the following properties: |
| |
| - `start` - Time when the request started. |
| - `socket` - Time when a socket was assigned to the request. |
| - `lookup` - Time when the DNS lookup finished. |
| - `connect` - Time when the socket successfully connected. |
| - `secureConnect` - Time when the socket securely connected. |
| - `upload` - Time when the request finished uploading. |
| - `response` - Time when the request fired `response` event. |
| - `end` - Time when the response fired `end` event. |
| - `error` - Time when the request fired `error` event. |
| - `abort` - Time when the request fired `abort` event. |
| - `phases` |
| - `wait` - `timings.socket - timings.start` |
| - `dns` - `timings.lookup - timings.socket` |
| - `tcp` - `timings.connect - timings.lookup` |
| - `tls` - `timings.secureConnect - timings.connect` |
| - `request` - `timings.upload - (timings.secureConnect || timings.connect)` |
| - `firstByte` - `timings.response - timings.upload` |
| - `download` - `timings.end - timings.response` |
| - `total` - `(timings.end || timings.error || timings.abort) - timings.start` |
| |
| If something has not been measured yet, it will be `undefined`. |
| |
| __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch. |
| */ |
| get timings() { |
| var _a; |
| return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.timings; |
| } |
| /** |
| Whether the response was retrieved from the cache. |
| */ |
| get isFromCache() { |
| return this[kIsFromCache]; |
| } |
| pipe(destination, options) { |
| if (this[kStartedReading]) { |
| throw new Error('Failed to pipe. The response has been emitted already.'); |
| } |
| if (destination instanceof http_1.ServerResponse) { |
| this[kServerResponsesPiped].add(destination); |
| } |
| return super.pipe(destination, options); |
| } |
| unpipe(destination) { |
| if (destination instanceof http_1.ServerResponse) { |
| this[kServerResponsesPiped].delete(destination); |
| } |
| super.unpipe(destination); |
| return this; |
| } |
| } |
| exports.default = Request; |
| |
| |
| /***/ }), |
| |
| /***/ 4993: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.dnsLookupIpVersionToFamily = exports.isDnsLookupIpVersion = void 0; |
| const conversionTable = { |
| auto: 0, |
| ipv4: 4, |
| ipv6: 6 |
| }; |
| exports.isDnsLookupIpVersion = (value) => { |
| return value in conversionTable; |
| }; |
| exports.dnsLookupIpVersionToFamily = (dnsLookupIpVersion) => { |
| if (exports.isDnsLookupIpVersion(dnsLookupIpVersion)) { |
| return conversionTable[dnsLookupIpVersion]; |
| } |
| throw new Error('Invalid DNS lookup IP version'); |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 4564: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const fs_1 = __nccwpck_require__(5747); |
| const util_1 = __nccwpck_require__(1669); |
| const is_1 = __nccwpck_require__(7678); |
| const is_form_data_1 = __nccwpck_require__(40); |
| const statAsync = util_1.promisify(fs_1.stat); |
| exports.default = async (body, headers) => { |
| if (headers && 'content-length' in headers) { |
| return Number(headers['content-length']); |
| } |
| if (!body) { |
| return 0; |
| } |
| if (is_1.default.string(body)) { |
| return Buffer.byteLength(body); |
| } |
| if (is_1.default.buffer(body)) { |
| return body.length; |
| } |
| if (is_form_data_1.default(body)) { |
| return util_1.promisify(body.getLength.bind(body))(); |
| } |
| if (body instanceof fs_1.ReadStream) { |
| const { size } = await statAsync(body.path); |
| if (size === 0) { |
| return undefined; |
| } |
| return size; |
| } |
| return undefined; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 4500: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| // TODO: Update https://github.com/sindresorhus/get-stream |
| const getBuffer = async (stream) => { |
| const chunks = []; |
| let length = 0; |
| for await (const chunk of stream) { |
| chunks.push(chunk); |
| length += Buffer.byteLength(chunk); |
| } |
| if (Buffer.isBuffer(chunks[0])) { |
| return Buffer.concat(chunks, length); |
| } |
| return Buffer.from(chunks.join('')); |
| }; |
| exports.default = getBuffer; |
| |
| |
| /***/ }), |
| |
| /***/ 40: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const is_1 = __nccwpck_require__(7678); |
| exports.default = (body) => is_1.default.nodeStream(body) && is_1.default.function_(body.getBoundary); |
| |
| |
| /***/ }), |
| |
| /***/ 9298: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.isResponseOk = void 0; |
| exports.isResponseOk = (response) => { |
| const { statusCode } = response; |
| const limitStatusCode = response.request.options.followRedirect ? 299 : 399; |
| return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 9219: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| /* istanbul ignore file: deprecated */ |
| const url_1 = __nccwpck_require__(8835); |
| const keys = [ |
| 'protocol', |
| 'host', |
| 'hostname', |
| 'port', |
| 'pathname', |
| 'search' |
| ]; |
| exports.default = (origin, options) => { |
| var _a, _b; |
| if (options.path) { |
| if (options.pathname) { |
| throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.'); |
| } |
| if (options.search) { |
| throw new TypeError('Parameters `path` and `search` are mutually exclusive.'); |
| } |
| if (options.searchParams) { |
| throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.'); |
| } |
| } |
| if (options.search && options.searchParams) { |
| throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.'); |
| } |
| if (!origin) { |
| if (!options.protocol) { |
| throw new TypeError('No URL protocol specified'); |
| } |
| origin = `${options.protocol}//${(_b = (_a = options.hostname) !== null && _a !== void 0 ? _a : options.host) !== null && _b !== void 0 ? _b : ''}`; |
| } |
| const url = new url_1.URL(origin); |
| if (options.path) { |
| const searchIndex = options.path.indexOf('?'); |
| if (searchIndex === -1) { |
| options.pathname = options.path; |
| } |
| else { |
| options.pathname = options.path.slice(0, searchIndex); |
| options.search = options.path.slice(searchIndex + 1); |
| } |
| delete options.path; |
| } |
| for (const key of keys) { |
| if (options[key]) { |
| url[key] = options[key].toString(); |
| } |
| } |
| return url; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 3021: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| function default_1(from, to, events) { |
| const fns = {}; |
| for (const event of events) { |
| fns[event] = (...args) => { |
| to.emit(event, ...args); |
| }; |
| from.on(event, fns[event]); |
| } |
| return () => { |
| for (const event of events) { |
| from.off(event, fns[event]); |
| } |
| }; |
| } |
| exports.default = default_1; |
| |
| |
| /***/ }), |
| |
| /***/ 2454: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.TimeoutError = void 0; |
| const net = __nccwpck_require__(1631); |
| const unhandle_1 = __nccwpck_require__(1593); |
| const reentry = Symbol('reentry'); |
| const noop = () => { }; |
| class TimeoutError extends Error { |
| constructor(threshold, event) { |
| super(`Timeout awaiting '${event}' for ${threshold}ms`); |
| this.event = event; |
| this.name = 'TimeoutError'; |
| this.code = 'ETIMEDOUT'; |
| } |
| } |
| exports.TimeoutError = TimeoutError; |
| exports.default = (request, delays, options) => { |
| if (reentry in request) { |
| return noop; |
| } |
| request[reentry] = true; |
| const cancelers = []; |
| const { once, unhandleAll } = unhandle_1.default(); |
| const addTimeout = (delay, callback, event) => { |
| var _a; |
| const timeout = setTimeout(callback, delay, delay, event); |
| (_a = timeout.unref) === null || _a === void 0 ? void 0 : _a.call(timeout); |
| const cancel = () => { |
| clearTimeout(timeout); |
| }; |
| cancelers.push(cancel); |
| return cancel; |
| }; |
| const { host, hostname } = options; |
| const timeoutHandler = (delay, event) => { |
| request.destroy(new TimeoutError(delay, event)); |
| }; |
| const cancelTimeouts = () => { |
| for (const cancel of cancelers) { |
| cancel(); |
| } |
| unhandleAll(); |
| }; |
| request.once('error', error => { |
| cancelTimeouts(); |
| // Save original behavior |
| /* istanbul ignore next */ |
| if (request.listenerCount('error') === 0) { |
| throw error; |
| } |
| }); |
| request.once('close', cancelTimeouts); |
| once(request, 'response', (response) => { |
| once(response, 'end', cancelTimeouts); |
| }); |
| if (typeof delays.request !== 'undefined') { |
| addTimeout(delays.request, timeoutHandler, 'request'); |
| } |
| if (typeof delays.socket !== 'undefined') { |
| const socketTimeoutHandler = () => { |
| timeoutHandler(delays.socket, 'socket'); |
| }; |
| request.setTimeout(delays.socket, socketTimeoutHandler); |
| // `request.setTimeout(0)` causes a memory leak. |
| // We can just remove the listener and forget about the timer - it's unreffed. |
| // See https://github.com/sindresorhus/got/issues/690 |
| cancelers.push(() => { |
| request.removeListener('timeout', socketTimeoutHandler); |
| }); |
| } |
| once(request, 'socket', (socket) => { |
| var _a; |
| const { socketPath } = request; |
| /* istanbul ignore next: hard to test */ |
| if (socket.connecting) { |
| const hasPath = Boolean(socketPath !== null && socketPath !== void 0 ? socketPath : net.isIP((_a = hostname !== null && hostname !== void 0 ? hostname : host) !== null && _a !== void 0 ? _a : '') !== 0); |
| if (typeof delays.lookup !== 'undefined' && !hasPath && typeof socket.address().address === 'undefined') { |
| const cancelTimeout = addTimeout(delays.lookup, timeoutHandler, 'lookup'); |
| once(socket, 'lookup', cancelTimeout); |
| } |
| if (typeof delays.connect !== 'undefined') { |
| const timeConnect = () => addTimeout(delays.connect, timeoutHandler, 'connect'); |
| if (hasPath) { |
| once(socket, 'connect', timeConnect()); |
| } |
| else { |
| once(socket, 'lookup', (error) => { |
| if (error === null) { |
| once(socket, 'connect', timeConnect()); |
| } |
| }); |
| } |
| } |
| if (typeof delays.secureConnect !== 'undefined' && options.protocol === 'https:') { |
| once(socket, 'connect', () => { |
| const cancelTimeout = addTimeout(delays.secureConnect, timeoutHandler, 'secureConnect'); |
| once(socket, 'secureConnect', cancelTimeout); |
| }); |
| } |
| } |
| if (typeof delays.send !== 'undefined') { |
| const timeRequest = () => addTimeout(delays.send, timeoutHandler, 'send'); |
| /* istanbul ignore next: hard to test */ |
| if (socket.connecting) { |
| once(socket, 'connect', () => { |
| once(request, 'upload-complete', timeRequest()); |
| }); |
| } |
| else { |
| once(request, 'upload-complete', timeRequest()); |
| } |
| } |
| }); |
| if (typeof delays.response !== 'undefined') { |
| once(request, 'upload-complete', () => { |
| const cancelTimeout = addTimeout(delays.response, timeoutHandler, 'response'); |
| once(request, 'response', cancelTimeout); |
| }); |
| } |
| return cancelTimeouts; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 1593: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| // When attaching listeners, it's very easy to forget about them. |
| // Especially if you do error handling and set timeouts. |
| // So instead of checking if it's proper to throw an error on every timeout ever, |
| // use this simple tool which will remove all listeners you have attached. |
| exports.default = () => { |
| const handlers = []; |
| return { |
| once(origin, event, fn) { |
| origin.once(event, fn); |
| handlers.push({ origin, event, fn }); |
| }, |
| unhandleAll() { |
| for (const handler of handlers) { |
| const { origin, event, fn } = handler; |
| origin.removeListener(event, fn); |
| } |
| handlers.length = 0; |
| } |
| }; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 8026: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const is_1 = __nccwpck_require__(7678); |
| exports.default = (url) => { |
| // Cast to URL |
| url = url; |
| const options = { |
| protocol: url.protocol, |
| hostname: is_1.default.string(url.hostname) && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname, |
| host: url.host, |
| hash: url.hash, |
| search: url.search, |
| pathname: url.pathname, |
| href: url.href, |
| path: `${url.pathname || ''}${url.search || ''}` |
| }; |
| if (is_1.default.string(url.port) && url.port.length > 0) { |
| options.port = Number(url.port); |
| } |
| if (url.username || url.password) { |
| options.auth = `${url.username || ''}:${url.password || ''}`; |
| } |
| return options; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 7288: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| class WeakableMap { |
| constructor() { |
| this.weakMap = new WeakMap(); |
| this.map = new Map(); |
| } |
| set(key, value) { |
| if (typeof key === 'object') { |
| this.weakMap.set(key, value); |
| } |
| else { |
| this.map.set(key, value); |
| } |
| } |
| get(key) { |
| if (typeof key === 'object') { |
| return this.weakMap.get(key); |
| } |
| return this.map.get(key); |
| } |
| has(key) { |
| if (typeof key === 'object') { |
| return this.weakMap.has(key); |
| } |
| return this.map.has(key); |
| } |
| } |
| exports.default = WeakableMap; |
| |
| |
| /***/ }), |
| |
| /***/ 4337: |
| /***/ (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 __exportStar = (this && this.__exportStar) || function(m, exports) { |
| for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.defaultHandler = void 0; |
| const is_1 = __nccwpck_require__(7678); |
| const as_promise_1 = __nccwpck_require__(6056); |
| const create_rejection_1 = __nccwpck_require__(6457); |
| const core_1 = __nccwpck_require__(94); |
| const deep_freeze_1 = __nccwpck_require__(285); |
| const errors = { |
| RequestError: as_promise_1.RequestError, |
| CacheError: as_promise_1.CacheError, |
| ReadError: as_promise_1.ReadError, |
| HTTPError: as_promise_1.HTTPError, |
| MaxRedirectsError: as_promise_1.MaxRedirectsError, |
| TimeoutError: as_promise_1.TimeoutError, |
| ParseError: as_promise_1.ParseError, |
| CancelError: as_promise_1.CancelError, |
| UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError, |
| UploadError: as_promise_1.UploadError |
| }; |
| // The `delay` package weighs 10KB (!) |
| const delay = async (ms) => new Promise(resolve => { |
| setTimeout(resolve, ms); |
| }); |
| const { normalizeArguments } = core_1.default; |
| const mergeOptions = (...sources) => { |
| let mergedOptions; |
| for (const source of sources) { |
| mergedOptions = normalizeArguments(undefined, source, mergedOptions); |
| } |
| return mergedOptions; |
| }; |
| const getPromiseOrStream = (options) => options.isStream ? new core_1.default(undefined, options) : as_promise_1.default(options); |
| const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults); |
| const aliases = [ |
| 'get', |
| 'post', |
| 'put', |
| 'patch', |
| 'head', |
| 'delete' |
| ]; |
| exports.defaultHandler = (options, next) => next(options); |
| const callInitHooks = (hooks, options) => { |
| if (hooks) { |
| for (const hook of hooks) { |
| hook(options); |
| } |
| } |
| }; |
| const create = (defaults) => { |
| // Proxy properties from next handlers |
| defaults._rawHandlers = defaults.handlers; |
| defaults.handlers = defaults.handlers.map(fn => ((options, next) => { |
| // This will be assigned by assigning result |
| let root; |
| const result = fn(options, newOptions => { |
| root = next(newOptions); |
| return root; |
| }); |
| if (result !== root && !options.isStream && root) { |
| const typedResult = result; |
| const { then: promiseThen, catch: promiseCatch, finally: promiseFianlly } = typedResult; |
| Object.setPrototypeOf(typedResult, Object.getPrototypeOf(root)); |
| Object.defineProperties(typedResult, Object.getOwnPropertyDescriptors(root)); |
| // These should point to the new promise |
| // eslint-disable-next-line promise/prefer-await-to-then |
| typedResult.then = promiseThen; |
| typedResult.catch = promiseCatch; |
| typedResult.finally = promiseFianlly; |
| } |
| return result; |
| })); |
| // Got interface |
| const got = ((url, options = {}, _defaults) => { |
| var _a, _b; |
| let iteration = 0; |
| const iterateHandlers = (newOptions) => { |
| return defaults.handlers[iteration++](newOptions, iteration === defaults.handlers.length ? getPromiseOrStream : iterateHandlers); |
| }; |
| // TODO: Remove this in Got 12. |
| if (is_1.default.plainObject(url)) { |
| const mergedOptions = { |
| ...url, |
| ...options |
| }; |
| core_1.setNonEnumerableProperties([url, options], mergedOptions); |
| options = mergedOptions; |
| url = undefined; |
| } |
| try { |
| // Call `init` hooks |
| let initHookError; |
| try { |
| callInitHooks(defaults.options.hooks.init, options); |
| callInitHooks((_a = options.hooks) === null || _a === void 0 ? void 0 : _a.init, options); |
| } |
| catch (error) { |
| initHookError = error; |
| } |
| // Normalize options & call handlers |
| const normalizedOptions = normalizeArguments(url, options, _defaults !== null && _defaults !== void 0 ? _defaults : defaults.options); |
| normalizedOptions[core_1.kIsNormalizedAlready] = true; |
| if (initHookError) { |
| throw new as_promise_1.RequestError(initHookError.message, initHookError, normalizedOptions); |
| } |
| return iterateHandlers(normalizedOptions); |
| } |
| catch (error) { |
| if (options.isStream) { |
| throw error; |
| } |
| else { |
| return create_rejection_1.default(error, defaults.options.hooks.beforeError, (_b = options.hooks) === null || _b === void 0 ? void 0 : _b.beforeError); |
| } |
| } |
| }); |
| got.extend = (...instancesOrOptions) => { |
| const optionsArray = [defaults.options]; |
| let handlers = [...defaults._rawHandlers]; |
| let isMutableDefaults; |
| for (const value of instancesOrOptions) { |
| if (isGotInstance(value)) { |
| optionsArray.push(value.defaults.options); |
| handlers.push(...value.defaults._rawHandlers); |
| isMutableDefaults = value.defaults.mutableDefaults; |
| } |
| else { |
| optionsArray.push(value); |
| if ('handlers' in value) { |
| handlers.push(...value.handlers); |
| } |
| isMutableDefaults = value.mutableDefaults; |
| } |
| } |
| handlers = handlers.filter(handler => handler !== exports.defaultHandler); |
| if (handlers.length === 0) { |
| handlers.push(exports.defaultHandler); |
| } |
| return create({ |
| options: mergeOptions(...optionsArray), |
| handlers, |
| mutableDefaults: Boolean(isMutableDefaults) |
| }); |
| }; |
| // Pagination |
| const paginateEach = (async function* (url, options) { |
| // TODO: Remove this `@ts-expect-error` when upgrading to TypeScript 4. |
| // Error: Argument of type 'Merge<Options, PaginationOptions<T, R>> | undefined' is not assignable to parameter of type 'Options | undefined'. |
| // @ts-expect-error |
| let normalizedOptions = normalizeArguments(url, options, defaults.options); |
| normalizedOptions.resolveBodyOnly = false; |
| const pagination = normalizedOptions.pagination; |
| if (!is_1.default.object(pagination)) { |
| throw new TypeError('`options.pagination` must be implemented'); |
| } |
| const all = []; |
| let { countLimit } = pagination; |
| let numberOfRequests = 0; |
| while (numberOfRequests < pagination.requestLimit) { |
| if (numberOfRequests !== 0) { |
| // eslint-disable-next-line no-await-in-loop |
| await delay(pagination.backoff); |
| } |
| // @ts-expect-error FIXME! |
| // TODO: Throw when result is not an instance of Response |
| // eslint-disable-next-line no-await-in-loop |
| const result = (await got(undefined, undefined, normalizedOptions)); |
| // eslint-disable-next-line no-await-in-loop |
| const parsed = await pagination.transform(result); |
| const current = []; |
| for (const item of parsed) { |
| if (pagination.filter(item, all, current)) { |
| if (!pagination.shouldContinue(item, all, current)) { |
| return; |
| } |
| yield item; |
| if (pagination.stackAllItems) { |
| all.push(item); |
| } |
| current.push(item); |
| if (--countLimit <= 0) { |
| return; |
| } |
| } |
| } |
| const optionsToMerge = pagination.paginate(result, all, current); |
| if (optionsToMerge === false) { |
| return; |
| } |
| if (optionsToMerge === result.request.options) { |
| normalizedOptions = result.request.options; |
| } |
| else if (optionsToMerge !== undefined) { |
| normalizedOptions = normalizeArguments(undefined, optionsToMerge, normalizedOptions); |
| } |
| numberOfRequests++; |
| } |
| }); |
| got.paginate = paginateEach; |
| got.paginate.all = (async (url, options) => { |
| const results = []; |
| for await (const item of paginateEach(url, options)) { |
| results.push(item); |
| } |
| return results; |
| }); |
| // For those who like very descriptive names |
| got.paginate.each = paginateEach; |
| // Stream API |
| got.stream = ((url, options) => got(url, { ...options, isStream: true })); |
| // Shortcuts |
| for (const method of aliases) { |
| got[method] = ((url, options) => got(url, { ...options, method })); |
| got.stream[method] = ((url, options) => { |
| return got(url, { ...options, method, isStream: true }); |
| }); |
| } |
| Object.assign(got, errors); |
| Object.defineProperty(got, 'defaults', { |
| value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults), |
| writable: defaults.mutableDefaults, |
| configurable: defaults.mutableDefaults, |
| enumerable: true |
| }); |
| got.mergeOptions = mergeOptions; |
| return got; |
| }; |
| exports.default = create; |
| __exportStar(__nccwpck_require__(2613), exports); |
| |
| |
| /***/ }), |
| |
| /***/ 3061: |
| /***/ (function(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 __exportStar = (this && this.__exportStar) || function(m, exports) { |
| for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); |
| }; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const url_1 = __nccwpck_require__(8835); |
| const create_1 = __nccwpck_require__(4337); |
| const defaults = { |
| options: { |
| method: 'GET', |
| retry: { |
| limit: 2, |
| methods: [ |
| 'GET', |
| 'PUT', |
| 'HEAD', |
| 'DELETE', |
| 'OPTIONS', |
| 'TRACE' |
| ], |
| statusCodes: [ |
| 408, |
| 413, |
| 429, |
| 500, |
| 502, |
| 503, |
| 504, |
| 521, |
| 522, |
| 524 |
| ], |
| errorCodes: [ |
| 'ETIMEDOUT', |
| 'ECONNRESET', |
| 'EADDRINUSE', |
| 'ECONNREFUSED', |
| 'EPIPE', |
| 'ENOTFOUND', |
| 'ENETUNREACH', |
| 'EAI_AGAIN' |
| ], |
| maxRetryAfter: undefined, |
| calculateDelay: ({ computedValue }) => computedValue |
| }, |
| timeout: {}, |
| headers: { |
| 'user-agent': 'got (https://github.com/sindresorhus/got)' |
| }, |
| hooks: { |
| init: [], |
| beforeRequest: [], |
| beforeRedirect: [], |
| beforeRetry: [], |
| beforeError: [], |
| afterResponse: [] |
| }, |
| cache: undefined, |
| dnsCache: undefined, |
| decompress: true, |
| throwHttpErrors: true, |
| followRedirect: true, |
| isStream: false, |
| responseType: 'text', |
| resolveBodyOnly: false, |
| maxRedirects: 10, |
| prefixUrl: '', |
| methodRewriting: true, |
| ignoreInvalidCookies: false, |
| context: {}, |
| // TODO: Set this to `true` when Got 12 gets released |
| http2: false, |
| allowGetBody: false, |
| https: undefined, |
| pagination: { |
| transform: (response) => { |
| if (response.request.options.responseType === 'json') { |
| return response.body; |
| } |
| return JSON.parse(response.body); |
| }, |
| paginate: response => { |
| if (!Reflect.has(response.headers, 'link')) { |
| return false; |
| } |
| const items = response.headers.link.split(','); |
| let next; |
| for (const item of items) { |
| const parsed = item.split(';'); |
| if (parsed[1].includes('next')) { |
| next = parsed[0].trimStart().trim(); |
| next = next.slice(1, -1); |
| break; |
| } |
| } |
| if (next) { |
| const options = { |
| url: new url_1.URL(next) |
| }; |
| return options; |
| } |
| return false; |
| }, |
| filter: () => true, |
| shouldContinue: () => true, |
| countLimit: Infinity, |
| backoff: 0, |
| requestLimit: 10000, |
| stackAllItems: true |
| }, |
| parseJson: (text) => JSON.parse(text), |
| stringifyJson: (object) => JSON.stringify(object), |
| cacheOptions: {} |
| }, |
| handlers: [create_1.defaultHandler], |
| mutableDefaults: false |
| }; |
| const got = create_1.default(defaults); |
| exports.default = got; |
| // For CommonJS default export support |
| module.exports = got; |
| module.exports.default = got; |
| module.exports.__esModule = true; // Workaround for TS issue: https://github.com/sindresorhus/got/pull/1267 |
| __exportStar(__nccwpck_require__(4337), exports); |
| __exportStar(__nccwpck_require__(6056), exports); |
| |
| |
| /***/ }), |
| |
| /***/ 2613: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| |
| /***/ }), |
| |
| /***/ 285: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const is_1 = __nccwpck_require__(7678); |
| function deepFreeze(object) { |
| for (const value of Object.values(object)) { |
| if (is_1.default.plainObject(value) || is_1.default.array(value)) { |
| deepFreeze(value); |
| } |
| } |
| return Object.freeze(object); |
| } |
| exports.default = deepFreeze; |
| |
| |
| /***/ }), |
| |
| /***/ 397: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| const alreadyWarned = new Set(); |
| exports.default = (message) => { |
| if (alreadyWarned.has(message)) { |
| return; |
| } |
| alreadyWarned.add(message); |
| // @ts-expect-error Missing types. |
| process.emitWarning(`Got: ${message}`, { |
| type: 'DeprecationWarning' |
| }); |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 1002: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| // rfc7231 6.1 |
| const statusCodeCacheableByDefault = new Set([ |
| 200, |
| 203, |
| 204, |
| 206, |
| 300, |
| 301, |
| 404, |
| 405, |
| 410, |
| 414, |
| 501, |
| ]); |
| |
| // This implementation does not understand partial responses (206) |
| const understoodStatuses = new Set([ |
| 200, |
| 203, |
| 204, |
| 300, |
| 301, |
| 302, |
| 303, |
| 307, |
| 308, |
| 404, |
| 405, |
| 410, |
| 414, |
| 501, |
| ]); |
| |
| const errorStatusCodes = new Set([ |
| 500, |
| 502, |
| 503, |
| 504, |
| ]); |
| |
| const hopByHopHeaders = { |
| date: true, // included, because we add Age update Date |
| connection: true, |
| 'keep-alive': true, |
| 'proxy-authenticate': true, |
| 'proxy-authorization': true, |
| te: true, |
| trailer: true, |
| 'transfer-encoding': true, |
| upgrade: true, |
| }; |
| |
| const excludedFromRevalidationUpdate = { |
| // Since the old body is reused, it doesn't make sense to change properties of the body |
| 'content-length': true, |
| 'content-encoding': true, |
| 'transfer-encoding': true, |
| 'content-range': true, |
| }; |
| |
| function toNumberOrZero(s) { |
| const n = parseInt(s, 10); |
| return isFinite(n) ? n : 0; |
| } |
| |
| // RFC 5861 |
| function isErrorResponse(response) { |
| // consider undefined response as faulty |
| if(!response) { |
| return true |
| } |
| return errorStatusCodes.has(response.status); |
| } |
| |
| function parseCacheControl(header) { |
| const cc = {}; |
| if (!header) return cc; |
| |
| // TODO: When there is more than one value present for a given directive (e.g., two Expires header fields, multiple Cache-Control: max-age directives), |
| // the directive's value is considered invalid. Caches are encouraged to consider responses that have invalid freshness information to be stale |
| const parts = header.trim().split(/\s*,\s*/); // TODO: lame parsing |
| for (const part of parts) { |
| const [k, v] = part.split(/\s*=\s*/, 2); |
| cc[k] = v === undefined ? true : v.replace(/^"|"$/g, ''); // TODO: lame unquoting |
| } |
| |
| return cc; |
| } |
| |
| function formatCacheControl(cc) { |
| let parts = []; |
| for (const k in cc) { |
| const v = cc[k]; |
| parts.push(v === true ? k : k + '=' + v); |
| } |
| if (!parts.length) { |
| return undefined; |
| } |
| return parts.join(', '); |
| } |
| |
| module.exports = class CachePolicy { |
| constructor( |
| req, |
| res, |
| { |
| shared, |
| cacheHeuristic, |
| immutableMinTimeToLive, |
| ignoreCargoCult, |
| _fromObject, |
| } = {} |
| ) { |
| if (_fromObject) { |
| this._fromObject(_fromObject); |
| return; |
| } |
| |
| if (!res || !res.headers) { |
| throw Error('Response headers missing'); |
| } |
| this._assertRequestHasHeaders(req); |
| |
| this._responseTime = this.now(); |
| this._isShared = shared !== false; |
| this._cacheHeuristic = |
| undefined !== cacheHeuristic ? cacheHeuristic : 0.1; // 10% matches IE |
| this._immutableMinTtl = |
| undefined !== immutableMinTimeToLive |
| ? immutableMinTimeToLive |
| : 24 * 3600 * 1000; |
| |
| this._status = 'status' in res ? res.status : 200; |
| this._resHeaders = res.headers; |
| this._rescc = parseCacheControl(res.headers['cache-control']); |
| this._method = 'method' in req ? req.method : 'GET'; |
| this._url = req.url; |
| this._host = req.headers.host; |
| this._noAuthorization = !req.headers.authorization; |
| this._reqHeaders = res.headers.vary ? req.headers : null; // Don't keep all request headers if they won't be used |
| this._reqcc = parseCacheControl(req.headers['cache-control']); |
| |
| // Assume that if someone uses legacy, non-standard uncecessary options they don't understand caching, |
| // so there's no point stricly adhering to the blindly copy&pasted directives. |
| if ( |
| ignoreCargoCult && |
| 'pre-check' in this._rescc && |
| 'post-check' in this._rescc |
| ) { |
| delete this._rescc['pre-check']; |
| delete this._rescc['post-check']; |
| delete this._rescc['no-cache']; |
| delete this._rescc['no-store']; |
| delete this._rescc['must-revalidate']; |
| this._resHeaders = Object.assign({}, this._resHeaders, { |
| 'cache-control': formatCacheControl(this._rescc), |
| }); |
| delete this._resHeaders.expires; |
| delete this._resHeaders.pragma; |
| } |
| |
| // When the Cache-Control header field is not present in a request, caches MUST consider the no-cache request pragma-directive |
| // as having the same effect as if "Cache-Control: no-cache" were present (see Section 5.2.1). |
| if ( |
| res.headers['cache-control'] == null && |
| /no-cache/.test(res.headers.pragma) |
| ) { |
| this._rescc['no-cache'] = true; |
| } |
| } |
| |
| now() { |
| return Date.now(); |
| } |
| |
| storable() { |
| // The "no-store" request directive indicates that a cache MUST NOT store any part of either this request or any response to it. |
| return !!( |
| !this._reqcc['no-store'] && |
| // A cache MUST NOT store a response to any request, unless: |
| // The request method is understood by the cache and defined as being cacheable, and |
| ('GET' === this._method || |
| 'HEAD' === this._method || |
| ('POST' === this._method && this._hasExplicitExpiration())) && |
| // the response status code is understood by the cache, and |
| understoodStatuses.has(this._status) && |
| // the "no-store" cache directive does not appear in request or response header fields, and |
| !this._rescc['no-store'] && |
| // the "private" response directive does not appear in the response, if the cache is shared, and |
| (!this._isShared || !this._rescc.private) && |
| // the Authorization header field does not appear in the request, if the cache is shared, |
| (!this._isShared || |
| this._noAuthorization || |
| this._allowsStoringAuthenticated()) && |
| // the response either: |
| // contains an Expires header field, or |
| (this._resHeaders.expires || |
| // contains a max-age response directive, or |
| // contains a s-maxage response directive and the cache is shared, or |
| // contains a public response directive. |
| this._rescc['max-age'] || |
| (this._isShared && this._rescc['s-maxage']) || |
| this._rescc.public || |
| // has a status code that is defined as cacheable by default |
| statusCodeCacheableByDefault.has(this._status)) |
| ); |
| } |
| |
| _hasExplicitExpiration() { |
| // 4.2.1 Calculating Freshness Lifetime |
| return ( |
| (this._isShared && this._rescc['s-maxage']) || |
| this._rescc['max-age'] || |
| this._resHeaders.expires |
| ); |
| } |
| |
| _assertRequestHasHeaders(req) { |
| if (!req || !req.headers) { |
| throw Error('Request headers missing'); |
| } |
| } |
| |
| satisfiesWithoutRevalidation(req) { |
| this._assertRequestHasHeaders(req); |
| |
| // When presented with a request, a cache MUST NOT reuse a stored response, unless: |
| // the presented request does not contain the no-cache pragma (Section 5.4), nor the no-cache cache directive, |
| // unless the stored response is successfully validated (Section 4.3), and |
| const requestCC = parseCacheControl(req.headers['cache-control']); |
| if (requestCC['no-cache'] || /no-cache/.test(req.headers.pragma)) { |
| return false; |
| } |
| |
| if (requestCC['max-age'] && this.age() > requestCC['max-age']) { |
| return false; |
| } |
| |
| if ( |
| requestCC['min-fresh'] && |
| this.timeToLive() < 1000 * requestCC['min-fresh'] |
| ) { |
| return false; |
| } |
| |
| // the stored response is either: |
| // fresh, or allowed to be served stale |
| if (this.stale()) { |
| const allowsStale = |
| requestCC['max-stale'] && |
| !this._rescc['must-revalidate'] && |
| (true === requestCC['max-stale'] || |
| requestCC['max-stale'] > this.age() - this.maxAge()); |
| if (!allowsStale) { |
| return false; |
| } |
| } |
| |
| return this._requestMatches(req, false); |
| } |
| |
| _requestMatches(req, allowHeadMethod) { |
| // The presented effective request URI and that of the stored response match, and |
| return ( |
| (!this._url || this._url === req.url) && |
| this._host === req.headers.host && |
| // the request method associated with the stored response allows it to be used for the presented request, and |
| (!req.method || |
| this._method === req.method || |
| (allowHeadMethod && 'HEAD' === req.method)) && |
| // selecting header fields nominated by the stored response (if any) match those presented, and |
| this._varyMatches(req) |
| ); |
| } |
| |
| _allowsStoringAuthenticated() { |
| // following Cache-Control response directives (Section 5.2.2) have such an effect: must-revalidate, public, and s-maxage. |
| return ( |
| this._rescc['must-revalidate'] || |
| this._rescc.public || |
| this._rescc['s-maxage'] |
| ); |
| } |
| |
| _varyMatches(req) { |
| if (!this._resHeaders.vary) { |
| return true; |
| } |
| |
| // A Vary header field-value of "*" always fails to match |
| if (this._resHeaders.vary === '*') { |
| return false; |
| } |
| |
| const fields = this._resHeaders.vary |
| .trim() |
| .toLowerCase() |
| .split(/\s*,\s*/); |
| for (const name of fields) { |
| if (req.headers[name] !== this._reqHeaders[name]) return false; |
| } |
| return true; |
| } |
| |
| _copyWithoutHopByHopHeaders(inHeaders) { |
| const headers = {}; |
| for (const name in inHeaders) { |
| if (hopByHopHeaders[name]) continue; |
| headers[name] = inHeaders[name]; |
| } |
| // 9.1. Connection |
| if (inHeaders.connection) { |
| const tokens = inHeaders.connection.trim().split(/\s*,\s*/); |
| for (const name of tokens) { |
| delete headers[name]; |
| } |
| } |
| if (headers.warning) { |
| const warnings = headers.warning.split(/,/).filter(warning => { |
| return !/^\s*1[0-9][0-9]/.test(warning); |
| }); |
| if (!warnings.length) { |
| delete headers.warning; |
| } else { |
| headers.warning = warnings.join(',').trim(); |
| } |
| } |
| return headers; |
| } |
| |
| responseHeaders() { |
| const headers = this._copyWithoutHopByHopHeaders(this._resHeaders); |
| const age = this.age(); |
| |
| // A cache SHOULD generate 113 warning if it heuristically chose a freshness |
| // lifetime greater than 24 hours and the response's age is greater than 24 hours. |
| if ( |
| age > 3600 * 24 && |
| !this._hasExplicitExpiration() && |
| this.maxAge() > 3600 * 24 |
| ) { |
| headers.warning = |
| (headers.warning ? `${headers.warning}, ` : '') + |
| '113 - "rfc7234 5.5.4"'; |
| } |
| headers.age = `${Math.round(age)}`; |
| headers.date = new Date(this.now()).toUTCString(); |
| return headers; |
| } |
| |
| /** |
| * Value of the Date response header or current time if Date was invalid |
| * @return timestamp |
| */ |
| date() { |
| const serverDate = Date.parse(this._resHeaders.date); |
| if (isFinite(serverDate)) { |
| return serverDate; |
| } |
| return this._responseTime; |
| } |
| |
| /** |
| * Value of the Age header, in seconds, updated for the current time. |
| * May be fractional. |
| * |
| * @return Number |
| */ |
| age() { |
| let age = this._ageValue(); |
| |
| const residentTime = (this.now() - this._responseTime) / 1000; |
| return age + residentTime; |
| } |
| |
| _ageValue() { |
| return toNumberOrZero(this._resHeaders.age); |
| } |
| |
| /** |
| * Value of applicable max-age (or heuristic equivalent) in seconds. This counts since response's `Date`. |
| * |
| * For an up-to-date value, see `timeToLive()`. |
| * |
| * @return Number |
| */ |
| maxAge() { |
| if (!this.storable() || this._rescc['no-cache']) { |
| return 0; |
| } |
| |
| // Shared responses with cookies are cacheable according to the RFC, but IMHO it'd be unwise to do so by default |
| // so this implementation requires explicit opt-in via public header |
| if ( |
| this._isShared && |
| (this._resHeaders['set-cookie'] && |
| !this._rescc.public && |
| !this._rescc.immutable) |
| ) { |
| return 0; |
| } |
| |
| if (this._resHeaders.vary === '*') { |
| return 0; |
| } |
| |
| if (this._isShared) { |
| if (this._rescc['proxy-revalidate']) { |
| return 0; |
| } |
| // if a response includes the s-maxage directive, a shared cache recipient MUST ignore the Expires field. |
| if (this._rescc['s-maxage']) { |
| return toNumberOrZero(this._rescc['s-maxage']); |
| } |
| } |
| |
| // If a response includes a Cache-Control field with the max-age directive, a recipient MUST ignore the Expires field. |
| if (this._rescc['max-age']) { |
| return toNumberOrZero(this._rescc['max-age']); |
| } |
| |
| const defaultMinTtl = this._rescc.immutable ? this._immutableMinTtl : 0; |
| |
| const serverDate = this.date(); |
| if (this._resHeaders.expires) { |
| const expires = Date.parse(this._resHeaders.expires); |
| // A cache recipient MUST interpret invalid date formats, especially the value "0", as representing a time in the past (i.e., "already expired"). |
| if (Number.isNaN(expires) || expires < serverDate) { |
| return 0; |
| } |
| return Math.max(defaultMinTtl, (expires - serverDate) / 1000); |
| } |
| |
| if (this._resHeaders['last-modified']) { |
| const lastModified = Date.parse(this._resHeaders['last-modified']); |
| if (isFinite(lastModified) && serverDate > lastModified) { |
| return Math.max( |
| defaultMinTtl, |
| ((serverDate - lastModified) / 1000) * this._cacheHeuristic |
| ); |
| } |
| } |
| |
| return defaultMinTtl; |
| } |
| |
| timeToLive() { |
| const age = this.maxAge() - this.age(); |
| const staleIfErrorAge = age + toNumberOrZero(this._rescc['stale-if-error']); |
| const staleWhileRevalidateAge = age + toNumberOrZero(this._rescc['stale-while-revalidate']); |
| return Math.max(0, age, staleIfErrorAge, staleWhileRevalidateAge) * 1000; |
| } |
| |
| stale() { |
| return this.maxAge() <= this.age(); |
| } |
| |
| _useStaleIfError() { |
| return this.maxAge() + toNumberOrZero(this._rescc['stale-if-error']) > this.age(); |
| } |
| |
| useStaleWhileRevalidate() { |
| return this.maxAge() + toNumberOrZero(this._rescc['stale-while-revalidate']) > this.age(); |
| } |
| |
| static fromObject(obj) { |
| return new this(undefined, undefined, { _fromObject: obj }); |
| } |
| |
| _fromObject(obj) { |
| if (this._responseTime) throw Error('Reinitialized'); |
| if (!obj || obj.v !== 1) throw Error('Invalid serialization'); |
| |
| this._responseTime = obj.t; |
| this._isShared = obj.sh; |
| this._cacheHeuristic = obj.ch; |
| this._immutableMinTtl = |
| obj.imm !== undefined ? obj.imm : 24 * 3600 * 1000; |
| this._status = obj.st; |
| this._resHeaders = obj.resh; |
| this._rescc = obj.rescc; |
| this._method = obj.m; |
| this._url = obj.u; |
| this._host = obj.h; |
| this._noAuthorization = obj.a; |
| this._reqHeaders = obj.reqh; |
| this._reqcc = obj.reqcc; |
| } |
| |
| toObject() { |
| return { |
| v: 1, |
| t: this._responseTime, |
| sh: this._isShared, |
| ch: this._cacheHeuristic, |
| imm: this._immutableMinTtl, |
| st: this._status, |
| resh: this._resHeaders, |
| rescc: this._rescc, |
| m: this._method, |
| u: this._url, |
| h: this._host, |
| a: this._noAuthorization, |
| reqh: this._reqHeaders, |
| reqcc: this._reqcc, |
| }; |
| } |
| |
| /** |
| * Headers for sending to the origin server to revalidate stale response. |
| * Allows server to return 304 to allow reuse of the previous response. |
| * |
| * Hop by hop headers are always stripped. |
| * Revalidation headers may be added or removed, depending on request. |
| */ |
| revalidationHeaders(incomingReq) { |
| this._assertRequestHasHeaders(incomingReq); |
| const headers = this._copyWithoutHopByHopHeaders(incomingReq.headers); |
| |
| // This implementation does not understand range requests |
| delete headers['if-range']; |
| |
| if (!this._requestMatches(incomingReq, true) || !this.storable()) { |
| // revalidation allowed via HEAD |
| // not for the same resource, or wasn't allowed to be cached anyway |
| delete headers['if-none-match']; |
| delete headers['if-modified-since']; |
| return headers; |
| } |
| |
| /* MUST send that entity-tag in any cache validation request (using If-Match or If-None-Match) if an entity-tag has been provided by the origin server. */ |
| if (this._resHeaders.etag) { |
| headers['if-none-match'] = headers['if-none-match'] |
| ? `${headers['if-none-match']}, ${this._resHeaders.etag}` |
| : this._resHeaders.etag; |
| } |
| |
| // Clients MAY issue simple (non-subrange) GET requests with either weak validators or strong validators. Clients MUST NOT use weak validators in other forms of request. |
| const forbidsWeakValidators = |
| headers['accept-ranges'] || |
| headers['if-match'] || |
| headers['if-unmodified-since'] || |
| (this._method && this._method != 'GET'); |
| |
| /* SHOULD send the Last-Modified value in non-subrange cache validation requests (using If-Modified-Since) if only a Last-Modified value has been provided by the origin server. |
| Note: This implementation does not understand partial responses (206) */ |
| if (forbidsWeakValidators) { |
| delete headers['if-modified-since']; |
| |
| if (headers['if-none-match']) { |
| const etags = headers['if-none-match'] |
| .split(/,/) |
| .filter(etag => { |
| return !/^\s*W\//.test(etag); |
| }); |
| if (!etags.length) { |
| delete headers['if-none-match']; |
| } else { |
| headers['if-none-match'] = etags.join(',').trim(); |
| } |
| } |
| } else if ( |
| this._resHeaders['last-modified'] && |
| !headers['if-modified-since'] |
| ) { |
| headers['if-modified-since'] = this._resHeaders['last-modified']; |
| } |
| |
| return headers; |
| } |
| |
| /** |
| * Creates new CachePolicy with information combined from the previews response, |
| * and the new revalidation response. |
| * |
| * Returns {policy, modified} where modified is a boolean indicating |
| * whether the response body has been modified, and old cached body can't be used. |
| * |
| * @return {Object} {policy: CachePolicy, modified: Boolean} |
| */ |
| revalidatedPolicy(request, response) { |
| this._assertRequestHasHeaders(request); |
| if(this._useStaleIfError() && isErrorResponse(response)) { // I consider the revalidation request unsuccessful |
| return { |
| modified: false, |
| matches: false, |
| policy: this, |
| }; |
| } |
| if (!response || !response.headers) { |
| throw Error('Response headers missing'); |
| } |
| |
| // These aren't going to be supported exactly, since one CachePolicy object |
| // doesn't know about all the other cached objects. |
| let matches = false; |
| if (response.status !== undefined && response.status != 304) { |
| matches = false; |
| } else if ( |
| response.headers.etag && |
| !/^\s*W\//.test(response.headers.etag) |
| ) { |
| // "All of the stored responses with the same strong validator are selected. |
| // If none of the stored responses contain the same strong validator, |
| // then the cache MUST NOT use the new response to update any stored responses." |
| matches = |
| this._resHeaders.etag && |
| this._resHeaders.etag.replace(/^\s*W\//, '') === |
| response.headers.etag; |
| } else if (this._resHeaders.etag && response.headers.etag) { |
| // "If the new response contains a weak validator and that validator corresponds |
| // to one of the cache's stored responses, |
| // then the most recent of those matching stored responses is selected for update." |
| matches = |
| this._resHeaders.etag.replace(/^\s*W\//, '') === |
| response.headers.etag.replace(/^\s*W\//, ''); |
| } else if (this._resHeaders['last-modified']) { |
| matches = |
| this._resHeaders['last-modified'] === |
| response.headers['last-modified']; |
| } else { |
| // If the new response does not include any form of validator (such as in the case where |
| // a client generates an If-Modified-Since request from a source other than the Last-Modified |
| // response header field), and there is only one stored response, and that stored response also |
| // lacks a validator, then that stored response is selected for update. |
| if ( |
| !this._resHeaders.etag && |
| !this._resHeaders['last-modified'] && |
| !response.headers.etag && |
| !response.headers['last-modified'] |
| ) { |
| matches = true; |
| } |
| } |
| |
| if (!matches) { |
| return { |
| policy: new this.constructor(request, response), |
| // Client receiving 304 without body, even if it's invalid/mismatched has no option |
| // but to reuse a cached body. We don't have a good way to tell clients to do |
| // error recovery in such case. |
| modified: response.status != 304, |
| matches: false, |
| }; |
| } |
| |
| // use other header fields provided in the 304 (Not Modified) response to replace all instances |
| // of the corresponding header fields in the stored response. |
| const headers = {}; |
| for (const k in this._resHeaders) { |
| headers[k] = |
| k in response.headers && !excludedFromRevalidationUpdate[k] |
| ? response.headers[k] |
| : this._resHeaders[k]; |
| } |
| |
| const newResponse = Object.assign({}, response, { |
| status: this._status, |
| method: this._method, |
| headers, |
| }); |
| return { |
| policy: new this.constructor(request, newResponse, { |
| shared: this._isShared, |
| cacheHeuristic: this._cacheHeuristic, |
| immutableMinTimeToLive: this._immutableMinTtl, |
| }), |
| modified: false, |
| matches: true, |
| }; |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 9898: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const EventEmitter = __nccwpck_require__(8614); |
| const tls = __nccwpck_require__(4016); |
| const http2 = __nccwpck_require__(7565); |
| const QuickLRU = __nccwpck_require__(9273); |
| |
| const kCurrentStreamsCount = Symbol('currentStreamsCount'); |
| const kRequest = Symbol('request'); |
| const kOriginSet = Symbol('cachedOriginSet'); |
| const kGracefullyClosing = Symbol('gracefullyClosing'); |
| |
| const nameKeys = [ |
| // `http2.connect()` options |
| 'maxDeflateDynamicTableSize', |
| 'maxSessionMemory', |
| 'maxHeaderListPairs', |
| 'maxOutstandingPings', |
| 'maxReservedRemoteStreams', |
| 'maxSendHeaderBlockLength', |
| 'paddingStrategy', |
| |
| // `tls.connect()` options |
| 'localAddress', |
| 'path', |
| 'rejectUnauthorized', |
| 'minDHSize', |
| |
| // `tls.createSecureContext()` options |
| 'ca', |
| 'cert', |
| 'clientCertEngine', |
| 'ciphers', |
| 'key', |
| 'pfx', |
| 'servername', |
| 'minVersion', |
| 'maxVersion', |
| 'secureProtocol', |
| 'crl', |
| 'honorCipherOrder', |
| 'ecdhCurve', |
| 'dhparam', |
| 'secureOptions', |
| 'sessionIdContext' |
| ]; |
| |
| const getSortedIndex = (array, value, compare) => { |
| let low = 0; |
| let high = array.length; |
| |
| while (low < high) { |
| const mid = (low + high) >>> 1; |
| |
| /* istanbul ignore next */ |
| if (compare(array[mid], value)) { |
| // This never gets called because we use descending sort. Better to have this anyway. |
| low = mid + 1; |
| } else { |
| high = mid; |
| } |
| } |
| |
| return low; |
| }; |
| |
| const compareSessions = (a, b) => { |
| return a.remoteSettings.maxConcurrentStreams > b.remoteSettings.maxConcurrentStreams; |
| }; |
| |
| // See https://tools.ietf.org/html/rfc8336 |
| const closeCoveredSessions = (where, session) => { |
| // Clients SHOULD NOT emit new requests on any connection whose Origin |
| // Set is a proper subset of another connection's Origin Set, and they |
| // SHOULD close it once all outstanding requests are satisfied. |
| for (const coveredSession of where) { |
| if ( |
| // The set is a proper subset when its length is less than the other set. |
| coveredSession[kOriginSet].length < session[kOriginSet].length && |
| |
| // And the other set includes all elements of the subset. |
| coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) && |
| |
| // Makes sure that the session can handle all requests from the covered session. |
| coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams |
| ) { |
| // This allows pending requests to finish and prevents making new requests. |
| gracefullyClose(coveredSession); |
| } |
| } |
| }; |
| |
| // This is basically inverted `closeCoveredSessions(...)`. |
| const closeSessionIfCovered = (where, coveredSession) => { |
| for (const session of where) { |
| if ( |
| coveredSession[kOriginSet].length < session[kOriginSet].length && |
| coveredSession[kOriginSet].every(origin => session[kOriginSet].includes(origin)) && |
| coveredSession[kCurrentStreamsCount] + session[kCurrentStreamsCount] <= session.remoteSettings.maxConcurrentStreams |
| ) { |
| gracefullyClose(coveredSession); |
| } |
| } |
| }; |
| |
| const getSessions = ({agent, isFree}) => { |
| const result = {}; |
| |
| // eslint-disable-next-line guard-for-in |
| for (const normalizedOptions in agent.sessions) { |
| const sessions = agent.sessions[normalizedOptions]; |
| |
| const filtered = sessions.filter(session => { |
| const result = session[Agent.kCurrentStreamsCount] < session.remoteSettings.maxConcurrentStreams; |
| |
| return isFree ? result : !result; |
| }); |
| |
| if (filtered.length !== 0) { |
| result[normalizedOptions] = filtered; |
| } |
| } |
| |
| return result; |
| }; |
| |
| const gracefullyClose = session => { |
| session[kGracefullyClosing] = true; |
| |
| if (session[kCurrentStreamsCount] === 0) { |
| session.close(); |
| } |
| }; |
| |
| class Agent extends EventEmitter { |
| constructor({timeout = 60000, maxSessions = Infinity, maxFreeSessions = 10, maxCachedTlsSessions = 100} = {}) { |
| super(); |
| |
| // A session is considered busy when its current streams count |
| // is equal to or greater than the `maxConcurrentStreams` value. |
| |
| // A session is considered free when its current streams count |
| // is less than the `maxConcurrentStreams` value. |
| |
| // SESSIONS[NORMALIZED_OPTIONS] = []; |
| this.sessions = {}; |
| |
| // The queue for creating new sessions. It looks like this: |
| // QUEUE[NORMALIZED_OPTIONS][NORMALIZED_ORIGIN] = ENTRY_FUNCTION |
| // |
| // The entry function has `listeners`, `completed` and `destroyed` properties. |
| // `listeners` is an array of objects containing `resolve` and `reject` functions. |
| // `completed` is a boolean. It's set to true after ENTRY_FUNCTION is executed. |
| // `destroyed` is a boolean. If it's set to true, the session will be destroyed if hasn't connected yet. |
| this.queue = {}; |
| |
| // Each session will use this timeout value. |
| this.timeout = timeout; |
| |
| // Max sessions in total |
| this.maxSessions = maxSessions; |
| |
| // Max free sessions in total |
| // TODO: decreasing `maxFreeSessions` should close some sessions |
| this.maxFreeSessions = maxFreeSessions; |
| |
| this._freeSessionsCount = 0; |
| this._sessionsCount = 0; |
| |
| // We don't support push streams by default. |
| this.settings = { |
| enablePush: false |
| }; |
| |
| // Reusing TLS sessions increases performance. |
| this.tlsSessionCache = new QuickLRU({maxSize: maxCachedTlsSessions}); |
| } |
| |
| static normalizeOrigin(url, servername) { |
| if (typeof url === 'string') { |
| url = new URL(url); |
| } |
| |
| if (servername && url.hostname !== servername) { |
| url.hostname = servername; |
| } |
| |
| return url.origin; |
| } |
| |
| normalizeOptions(options) { |
| let normalized = ''; |
| |
| if (options) { |
| for (const key of nameKeys) { |
| if (options[key]) { |
| normalized += `:${options[key]}`; |
| } |
| } |
| } |
| |
| return normalized; |
| } |
| |
| _tryToCreateNewSession(normalizedOptions, normalizedOrigin) { |
| if (!(normalizedOptions in this.queue) || !(normalizedOrigin in this.queue[normalizedOptions])) { |
| return; |
| } |
| |
| const item = this.queue[normalizedOptions][normalizedOrigin]; |
| |
| // The entry function can be run only once. |
| // BUG: The session may be never created when: |
| // - the first condition is false AND |
| // - this function is never called with the same arguments in the future. |
| if (this._sessionsCount < this.maxSessions && !item.completed) { |
| item.completed = true; |
| |
| item(); |
| } |
| } |
| |
| getSession(origin, options, listeners) { |
| return new Promise((resolve, reject) => { |
| if (Array.isArray(listeners)) { |
| listeners = [...listeners]; |
| |
| // Resolve the current promise ASAP, we're just moving the listeners. |
| // They will be executed at a different time. |
| resolve(); |
| } else { |
| listeners = [{resolve, reject}]; |
| } |
| |
| const normalizedOptions = this.normalizeOptions(options); |
| const normalizedOrigin = Agent.normalizeOrigin(origin, options && options.servername); |
| |
| if (normalizedOrigin === undefined) { |
| for (const {reject} of listeners) { |
| reject(new TypeError('The `origin` argument needs to be a string or an URL object')); |
| } |
| |
| return; |
| } |
| |
| if (normalizedOptions in this.sessions) { |
| const sessions = this.sessions[normalizedOptions]; |
| |
| let maxConcurrentStreams = -1; |
| let currentStreamsCount = -1; |
| let optimalSession; |
| |
| // We could just do this.sessions[normalizedOptions].find(...) but that isn't optimal. |
| // Additionally, we are looking for session which has biggest current pending streams count. |
| for (const session of sessions) { |
| const sessionMaxConcurrentStreams = session.remoteSettings.maxConcurrentStreams; |
| |
| if (sessionMaxConcurrentStreams < maxConcurrentStreams) { |
| break; |
| } |
| |
| if (session[kOriginSet].includes(normalizedOrigin)) { |
| const sessionCurrentStreamsCount = session[kCurrentStreamsCount]; |
| |
| if ( |
| sessionCurrentStreamsCount >= sessionMaxConcurrentStreams || |
| session[kGracefullyClosing] || |
| // Unfortunately the `close` event isn't called immediately, |
| // so `session.destroyed` is `true`, but `session.closed` is `false`. |
| session.destroyed |
| ) { |
| continue; |
| } |
| |
| // We only need set this once. |
| if (!optimalSession) { |
| maxConcurrentStreams = sessionMaxConcurrentStreams; |
| } |
| |
| // We're looking for the session which has biggest current pending stream count, |
| // in order to minimalize the amount of active sessions. |
| if (sessionCurrentStreamsCount > currentStreamsCount) { |
| optimalSession = session; |
| currentStreamsCount = sessionCurrentStreamsCount; |
| } |
| } |
| } |
| |
| if (optimalSession) { |
| /* istanbul ignore next: safety check */ |
| if (listeners.length !== 1) { |
| for (const {reject} of listeners) { |
| const error = new Error( |
| `Expected the length of listeners to be 1, got ${listeners.length}.\n` + |
| 'Please report this to https://github.com/szmarczak/http2-wrapper/' |
| ); |
| |
| reject(error); |
| } |
| |
| return; |
| } |
| |
| listeners[0].resolve(optimalSession); |
| return; |
| } |
| } |
| |
| if (normalizedOptions in this.queue) { |
| if (normalizedOrigin in this.queue[normalizedOptions]) { |
| // There's already an item in the queue, just attach ourselves to it. |
| this.queue[normalizedOptions][normalizedOrigin].listeners.push(...listeners); |
| |
| // This shouldn't be executed here. |
| // See the comment inside _tryToCreateNewSession. |
| this._tryToCreateNewSession(normalizedOptions, normalizedOrigin); |
| return; |
| } |
| } else { |
| this.queue[normalizedOptions] = {}; |
| } |
| |
| // The entry must be removed from the queue IMMEDIATELY when: |
| // 1. the session connects successfully, |
| // 2. an error occurs. |
| const removeFromQueue = () => { |
| // Our entry can be replaced. We cannot remove the new one. |
| if (normalizedOptions in this.queue && this.queue[normalizedOptions][normalizedOrigin] === entry) { |
| delete this.queue[normalizedOptions][normalizedOrigin]; |
| |
| if (Object.keys(this.queue[normalizedOptions]).length === 0) { |
| delete this.queue[normalizedOptions]; |
| } |
| } |
| }; |
| |
| // The main logic is here |
| const entry = () => { |
| const name = `${normalizedOrigin}:${normalizedOptions}`; |
| let receivedSettings = false; |
| |
| try { |
| const session = http2.connect(origin, { |
| createConnection: this.createConnection, |
| settings: this.settings, |
| session: this.tlsSessionCache.get(name), |
| ...options |
| }); |
| session[kCurrentStreamsCount] = 0; |
| session[kGracefullyClosing] = false; |
| |
| const isFree = () => session[kCurrentStreamsCount] < session.remoteSettings.maxConcurrentStreams; |
| let wasFree = true; |
| |
| session.socket.once('session', tlsSession => { |
| this.tlsSessionCache.set(name, tlsSession); |
| }); |
| |
| session.once('error', error => { |
| // Listeners are empty when the session successfully connected. |
| for (const {reject} of listeners) { |
| reject(error); |
| } |
| |
| // The connection got broken, purge the cache. |
| this.tlsSessionCache.delete(name); |
| }); |
| |
| session.setTimeout(this.timeout, () => { |
| // Terminates all streams owned by this session. |
| // TODO: Maybe the streams should have a "Session timed out" error? |
| session.destroy(); |
| }); |
| |
| session.once('close', () => { |
| if (receivedSettings) { |
| // 1. If it wasn't free then no need to decrease because |
| // it has been decreased already in session.request(). |
| // 2. `stream.once('close')` won't increment the count |
| // because the session is already closed. |
| if (wasFree) { |
| this._freeSessionsCount--; |
| } |
| |
| this._sessionsCount--; |
| |
| // This cannot be moved to the stream logic, |
| // because there may be a session that hadn't made a single request. |
| const where = this.sessions[normalizedOptions]; |
| where.splice(where.indexOf(session), 1); |
| |
| if (where.length === 0) { |
| delete this.sessions[normalizedOptions]; |
| } |
| } else { |
| // Broken connection |
| const error = new Error('Session closed without receiving a SETTINGS frame'); |
| error.code = 'HTTP2WRAPPER_NOSETTINGS'; |
| |
| for (const {reject} of listeners) { |
| reject(error); |
| } |
| |
| removeFromQueue(); |
| } |
| |
| // There may be another session awaiting. |
| this._tryToCreateNewSession(normalizedOptions, normalizedOrigin); |
| }); |
| |
| // Iterates over the queue and processes listeners. |
| const processListeners = () => { |
| if (!(normalizedOptions in this.queue) || !isFree()) { |
| return; |
| } |
| |
| for (const origin of session[kOriginSet]) { |
| if (origin in this.queue[normalizedOptions]) { |
| const {listeners} = this.queue[normalizedOptions][origin]; |
| |
| // Prevents session overloading. |
| while (listeners.length !== 0 && isFree()) { |
| // We assume `resolve(...)` calls `request(...)` *directly*, |
| // otherwise the session will get overloaded. |
| listeners.shift().resolve(session); |
| } |
| |
| const where = this.queue[normalizedOptions]; |
| if (where[origin].listeners.length === 0) { |
| delete where[origin]; |
| |
| if (Object.keys(where).length === 0) { |
| delete this.queue[normalizedOptions]; |
| break; |
| } |
| } |
| |
| // We're no longer free, no point in continuing. |
| if (!isFree()) { |
| break; |
| } |
| } |
| } |
| }; |
| |
| // The Origin Set cannot shrink. No need to check if it suddenly became covered by another one. |
| session.on('origin', () => { |
| session[kOriginSet] = session.originSet; |
| |
| if (!isFree()) { |
| // The session is full. |
| return; |
| } |
| |
| processListeners(); |
| |
| // Close covered sessions (if possible). |
| closeCoveredSessions(this.sessions[normalizedOptions], session); |
| }); |
| |
| session.once('remoteSettings', () => { |
| // Fix Node.js bug preventing the process from exiting |
| session.ref(); |
| session.unref(); |
| |
| this._sessionsCount++; |
| |
| // The Agent could have been destroyed already. |
| if (entry.destroyed) { |
| const error = new Error('Agent has been destroyed'); |
| |
| for (const listener of listeners) { |
| listener.reject(error); |
| } |
| |
| session.destroy(); |
| return; |
| } |
| |
| session[kOriginSet] = session.originSet; |
| |
| { |
| const where = this.sessions; |
| |
| if (normalizedOptions in where) { |
| const sessions = where[normalizedOptions]; |
| sessions.splice(getSortedIndex(sessions, session, compareSessions), 0, session); |
| } else { |
| where[normalizedOptions] = [session]; |
| } |
| } |
| |
| this._freeSessionsCount += 1; |
| receivedSettings = true; |
| |
| this.emit('session', session); |
| |
| processListeners(); |
| removeFromQueue(); |
| |
| // TODO: Close last recently used (or least used?) session |
| if (session[kCurrentStreamsCount] === 0 && this._freeSessionsCount > this.maxFreeSessions) { |
| session.close(); |
| } |
| |
| // Check if we haven't managed to execute all listeners. |
| if (listeners.length !== 0) { |
| // Request for a new session with predefined listeners. |
| this.getSession(normalizedOrigin, options, listeners); |
| listeners.length = 0; |
| } |
| |
| // `session.remoteSettings.maxConcurrentStreams` might get increased |
| session.on('remoteSettings', () => { |
| processListeners(); |
| |
| // In case the Origin Set changes |
| closeCoveredSessions(this.sessions[normalizedOptions], session); |
| }); |
| }); |
| |
| // Shim `session.request()` in order to catch all streams |
| session[kRequest] = session.request; |
| session.request = (headers, streamOptions) => { |
| if (session[kGracefullyClosing]) { |
| throw new Error('The session is gracefully closing. No new streams are allowed.'); |
| } |
| |
| const stream = session[kRequest](headers, streamOptions); |
| |
| // The process won't exit until the session is closed or all requests are gone. |
| session.ref(); |
| |
| ++session[kCurrentStreamsCount]; |
| |
| if (session[kCurrentStreamsCount] === session.remoteSettings.maxConcurrentStreams) { |
| this._freeSessionsCount--; |
| } |
| |
| stream.once('close', () => { |
| wasFree = isFree(); |
| |
| --session[kCurrentStreamsCount]; |
| |
| if (!session.destroyed && !session.closed) { |
| closeSessionIfCovered(this.sessions[normalizedOptions], session); |
| |
| if (isFree() && !session.closed) { |
| if (!wasFree) { |
| this._freeSessionsCount++; |
| |
| wasFree = true; |
| } |
| |
| const isEmpty = session[kCurrentStreamsCount] === 0; |
| |
| if (isEmpty) { |
| session.unref(); |
| } |
| |
| if ( |
| isEmpty && |
| ( |
| this._freeSessionsCount > this.maxFreeSessions || |
| session[kGracefullyClosing] |
| ) |
| ) { |
| session.close(); |
| } else { |
| closeCoveredSessions(this.sessions[normalizedOptions], session); |
| processListeners(); |
| } |
| } |
| } |
| }); |
| |
| return stream; |
| }; |
| } catch (error) { |
| for (const listener of listeners) { |
| listener.reject(error); |
| } |
| |
| removeFromQueue(); |
| } |
| }; |
| |
| entry.listeners = listeners; |
| entry.completed = false; |
| entry.destroyed = false; |
| |
| this.queue[normalizedOptions][normalizedOrigin] = entry; |
| this._tryToCreateNewSession(normalizedOptions, normalizedOrigin); |
| }); |
| } |
| |
| request(origin, options, headers, streamOptions) { |
| return new Promise((resolve, reject) => { |
| this.getSession(origin, options, [{ |
| reject, |
| resolve: session => { |
| try { |
| resolve(session.request(headers, streamOptions)); |
| } catch (error) { |
| reject(error); |
| } |
| } |
| }]); |
| }); |
| } |
| |
| createConnection(origin, options) { |
| return Agent.connect(origin, options); |
| } |
| |
| static connect(origin, options) { |
| options.ALPNProtocols = ['h2']; |
| |
| const port = origin.port || 443; |
| const host = origin.hostname || origin.host; |
| |
| if (typeof options.servername === 'undefined') { |
| options.servername = host; |
| } |
| |
| return tls.connect(port, host, options); |
| } |
| |
| closeFreeSessions() { |
| for (const sessions of Object.values(this.sessions)) { |
| for (const session of sessions) { |
| if (session[kCurrentStreamsCount] === 0) { |
| session.close(); |
| } |
| } |
| } |
| } |
| |
| destroy(reason) { |
| for (const sessions of Object.values(this.sessions)) { |
| for (const session of sessions) { |
| session.destroy(reason); |
| } |
| } |
| |
| for (const entriesOfAuthority of Object.values(this.queue)) { |
| for (const entry of Object.values(entriesOfAuthority)) { |
| entry.destroyed = true; |
| } |
| } |
| |
| // New requests should NOT attach to destroyed sessions |
| this.queue = {}; |
| } |
| |
| get freeSessions() { |
| return getSessions({agent: this, isFree: true}); |
| } |
| |
| get busySessions() { |
| return getSessions({agent: this, isFree: false}); |
| } |
| } |
| |
| Agent.kCurrentStreamsCount = kCurrentStreamsCount; |
| Agent.kGracefullyClosing = kGracefullyClosing; |
| |
| module.exports = { |
| Agent, |
| globalAgent: new Agent() |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 7167: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const http = __nccwpck_require__(8605); |
| const https = __nccwpck_require__(7211); |
| const resolveALPN = __nccwpck_require__(6624); |
| const QuickLRU = __nccwpck_require__(9273); |
| const Http2ClientRequest = __nccwpck_require__(9632); |
| const calculateServerName = __nccwpck_require__(1982); |
| const urlToOptions = __nccwpck_require__(2686); |
| |
| const cache = new QuickLRU({maxSize: 100}); |
| const queue = new Map(); |
| |
| const installSocket = (agent, socket, options) => { |
| socket._httpMessage = {shouldKeepAlive: true}; |
| |
| const onFree = () => { |
| agent.emit('free', socket, options); |
| }; |
| |
| socket.on('free', onFree); |
| |
| const onClose = () => { |
| agent.removeSocket(socket, options); |
| }; |
| |
| socket.on('close', onClose); |
| |
| const onRemove = () => { |
| agent.removeSocket(socket, options); |
| socket.off('close', onClose); |
| socket.off('free', onFree); |
| socket.off('agentRemove', onRemove); |
| }; |
| |
| socket.on('agentRemove', onRemove); |
| |
| agent.emit('free', socket, options); |
| }; |
| |
| const resolveProtocol = async options => { |
| const name = `${options.host}:${options.port}:${options.ALPNProtocols.sort()}`; |
| |
| if (!cache.has(name)) { |
| if (queue.has(name)) { |
| const result = await queue.get(name); |
| return result.alpnProtocol; |
| } |
| |
| const {path, agent} = options; |
| options.path = options.socketPath; |
| |
| const resultPromise = resolveALPN(options); |
| queue.set(name, resultPromise); |
| |
| try { |
| const {socket, alpnProtocol} = await resultPromise; |
| cache.set(name, alpnProtocol); |
| |
| options.path = path; |
| |
| if (alpnProtocol === 'h2') { |
| // https://github.com/nodejs/node/issues/33343 |
| socket.destroy(); |
| } else { |
| const {globalAgent} = https; |
| const defaultCreateConnection = https.Agent.prototype.createConnection; |
| |
| if (agent) { |
| if (agent.createConnection === defaultCreateConnection) { |
| installSocket(agent, socket, options); |
| } else { |
| socket.destroy(); |
| } |
| } else if (globalAgent.createConnection === defaultCreateConnection) { |
| installSocket(globalAgent, socket, options); |
| } else { |
| socket.destroy(); |
| } |
| } |
| |
| queue.delete(name); |
| |
| return alpnProtocol; |
| } catch (error) { |
| queue.delete(name); |
| |
| throw error; |
| } |
| } |
| |
| return cache.get(name); |
| }; |
| |
| module.exports = async (input, options, callback) => { |
| if (typeof input === 'string' || input instanceof URL) { |
| input = urlToOptions(new URL(input)); |
| } |
| |
| if (typeof options === 'function') { |
| callback = options; |
| options = undefined; |
| } |
| |
| options = { |
| ALPNProtocols: ['h2', 'http/1.1'], |
| ...input, |
| ...options, |
| resolveSocket: true |
| }; |
| |
| if (!Array.isArray(options.ALPNProtocols) || options.ALPNProtocols.length === 0) { |
| throw new Error('The `ALPNProtocols` option must be an Array with at least one entry'); |
| } |
| |
| options.protocol = options.protocol || 'https:'; |
| const isHttps = options.protocol === 'https:'; |
| |
| options.host = options.hostname || options.host || 'localhost'; |
| options.session = options.tlsSession; |
| options.servername = options.servername || calculateServerName(options); |
| options.port = options.port || (isHttps ? 443 : 80); |
| options._defaultAgent = isHttps ? https.globalAgent : http.globalAgent; |
| |
| const agents = options.agent; |
| |
| if (agents) { |
| if (agents.addRequest) { |
| throw new Error('The `options.agent` object can contain only `http`, `https` or `http2` properties'); |
| } |
| |
| options.agent = agents[isHttps ? 'https' : 'http']; |
| } |
| |
| if (isHttps) { |
| const protocol = await resolveProtocol(options); |
| |
| if (protocol === 'h2') { |
| if (agents) { |
| options.agent = agents.http2; |
| } |
| |
| return new Http2ClientRequest(options, callback); |
| } |
| } |
| |
| return http.request(options, callback); |
| }; |
| |
| module.exports.protocolCache = cache; |
| |
| |
| /***/ }), |
| |
| /***/ 9632: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const http2 = __nccwpck_require__(7565); |
| const {Writable} = __nccwpck_require__(2413); |
| const {Agent, globalAgent} = __nccwpck_require__(9898); |
| const IncomingMessage = __nccwpck_require__(2575); |
| const urlToOptions = __nccwpck_require__(2686); |
| const proxyEvents = __nccwpck_require__(1818); |
| const isRequestPseudoHeader = __nccwpck_require__(1199); |
| const { |
| ERR_INVALID_ARG_TYPE, |
| ERR_INVALID_PROTOCOL, |
| ERR_HTTP_HEADERS_SENT, |
| ERR_INVALID_HTTP_TOKEN, |
| ERR_HTTP_INVALID_HEADER_VALUE, |
| ERR_INVALID_CHAR |
| } = __nccwpck_require__(7087); |
| |
| const { |
| HTTP2_HEADER_STATUS, |
| HTTP2_HEADER_METHOD, |
| HTTP2_HEADER_PATH, |
| HTTP2_METHOD_CONNECT |
| } = http2.constants; |
| |
| const kHeaders = Symbol('headers'); |
| const kOrigin = Symbol('origin'); |
| const kSession = Symbol('session'); |
| const kOptions = Symbol('options'); |
| const kFlushedHeaders = Symbol('flushedHeaders'); |
| const kJobs = Symbol('jobs'); |
| |
| const isValidHttpToken = /^[\^`\-\w!#$%&*+.|~]+$/; |
| const isInvalidHeaderValue = /[^\t\u0020-\u007E\u0080-\u00FF]/; |
| |
| class ClientRequest extends Writable { |
| constructor(input, options, callback) { |
| super({ |
| autoDestroy: false |
| }); |
| |
| const hasInput = typeof input === 'string' || input instanceof URL; |
| if (hasInput) { |
| input = urlToOptions(input instanceof URL ? input : new URL(input)); |
| } |
| |
| if (typeof options === 'function' || options === undefined) { |
| // (options, callback) |
| callback = options; |
| options = hasInput ? input : {...input}; |
| } else { |
| // (input, options, callback) |
| options = {...input, ...options}; |
| } |
| |
| if (options.h2session) { |
| this[kSession] = options.h2session; |
| } else if (options.agent === false) { |
| this.agent = new Agent({maxFreeSessions: 0}); |
| } else if (typeof options.agent === 'undefined' || options.agent === null) { |
| if (typeof options.createConnection === 'function') { |
| // This is a workaround - we don't have to create the session on our own. |
| this.agent = new Agent({maxFreeSessions: 0}); |
| this.agent.createConnection = options.createConnection; |
| } else { |
| this.agent = globalAgent; |
| } |
| } else if (typeof options.agent.request === 'function') { |
| this.agent = options.agent; |
| } else { |
| throw new ERR_INVALID_ARG_TYPE('options.agent', ['Agent-like Object', 'undefined', 'false'], options.agent); |
| } |
| |
| if (options.protocol && options.protocol !== 'https:') { |
| throw new ERR_INVALID_PROTOCOL(options.protocol, 'https:'); |
| } |
| |
| const port = options.port || options.defaultPort || (this.agent && this.agent.defaultPort) || 443; |
| const host = options.hostname || options.host || 'localhost'; |
| |
| // Don't enforce the origin via options. It may be changed in an Agent. |
| delete options.hostname; |
| delete options.host; |
| delete options.port; |
| |
| const {timeout} = options; |
| options.timeout = undefined; |
| |
| this[kHeaders] = Object.create(null); |
| this[kJobs] = []; |
| |
| this.socket = null; |
| this.connection = null; |
| |
| this.method = options.method || 'GET'; |
| this.path = options.path; |
| |
| this.res = null; |
| this.aborted = false; |
| this.reusedSocket = false; |
| |
| if (options.headers) { |
| for (const [header, value] of Object.entries(options.headers)) { |
| this.setHeader(header, value); |
| } |
| } |
| |
| if (options.auth && !('authorization' in this[kHeaders])) { |
| this[kHeaders].authorization = 'Basic ' + Buffer.from(options.auth).toString('base64'); |
| } |
| |
| options.session = options.tlsSession; |
| options.path = options.socketPath; |
| |
| this[kOptions] = options; |
| |
| // Clients that generate HTTP/2 requests directly SHOULD use the :authority pseudo-header field instead of the Host header field. |
| if (port === 443) { |
| this[kOrigin] = `https://${host}`; |
| |
| if (!(':authority' in this[kHeaders])) { |
| this[kHeaders][':authority'] = host; |
| } |
| } else { |
| this[kOrigin] = `https://${host}:${port}`; |
| |
| if (!(':authority' in this[kHeaders])) { |
| this[kHeaders][':authority'] = `${host}:${port}`; |
| } |
| } |
| |
| if (timeout) { |
| this.setTimeout(timeout); |
| } |
| |
| if (callback) { |
| this.once('response', callback); |
| } |
| |
| this[kFlushedHeaders] = false; |
| } |
| |
| get method() { |
| return this[kHeaders][HTTP2_HEADER_METHOD]; |
| } |
| |
| set method(value) { |
| if (value) { |
| this[kHeaders][HTTP2_HEADER_METHOD] = value.toUpperCase(); |
| } |
| } |
| |
| get path() { |
| return this[kHeaders][HTTP2_HEADER_PATH]; |
| } |
| |
| set path(value) { |
| if (value) { |
| this[kHeaders][HTTP2_HEADER_PATH] = value; |
| } |
| } |
| |
| get _mustNotHaveABody() { |
| return this.method === 'GET' || this.method === 'HEAD' || this.method === 'DELETE'; |
| } |
| |
| _write(chunk, encoding, callback) { |
| // https://github.com/nodejs/node/blob/654df09ae0c5e17d1b52a900a545f0664d8c7627/lib/internal/http2/util.js#L148-L156 |
| if (this._mustNotHaveABody) { |
| callback(new Error('The GET, HEAD and DELETE methods must NOT have a body')); |
| /* istanbul ignore next: Node.js 12 throws directly */ |
| return; |
| } |
| |
| this.flushHeaders(); |
| |
| const callWrite = () => this._request.write(chunk, encoding, callback); |
| if (this._request) { |
| callWrite(); |
| } else { |
| this[kJobs].push(callWrite); |
| } |
| } |
| |
| _final(callback) { |
| if (this.destroyed) { |
| return; |
| } |
| |
| this.flushHeaders(); |
| |
| const callEnd = () => { |
| // For GET, HEAD and DELETE |
| if (this._mustNotHaveABody) { |
| callback(); |
| return; |
| } |
| |
| this._request.end(callback); |
| }; |
| |
| if (this._request) { |
| callEnd(); |
| } else { |
| this[kJobs].push(callEnd); |
| } |
| } |
| |
| abort() { |
| if (this.res && this.res.complete) { |
| return; |
| } |
| |
| if (!this.aborted) { |
| process.nextTick(() => this.emit('abort')); |
| } |
| |
| this.aborted = true; |
| |
| this.destroy(); |
| } |
| |
| _destroy(error, callback) { |
| if (this.res) { |
| this.res._dump(); |
| } |
| |
| if (this._request) { |
| this._request.destroy(); |
| } |
| |
| callback(error); |
| } |
| |
| async flushHeaders() { |
| if (this[kFlushedHeaders] || this.destroyed) { |
| return; |
| } |
| |
| this[kFlushedHeaders] = true; |
| |
| const isConnectMethod = this.method === HTTP2_METHOD_CONNECT; |
| |
| // The real magic is here |
| const onStream = stream => { |
| this._request = stream; |
| |
| if (this.destroyed) { |
| stream.destroy(); |
| return; |
| } |
| |
| // Forwards `timeout`, `continue`, `close` and `error` events to this instance. |
| if (!isConnectMethod) { |
| proxyEvents(stream, this, ['timeout', 'continue', 'close', 'error']); |
| } |
| |
| // Wait for the `finish` event. We don't want to emit the `response` event |
| // before `request.end()` is called. |
| const waitForEnd = fn => { |
| return (...args) => { |
| if (!this.writable && !this.destroyed) { |
| fn(...args); |
| } else { |
| this.once('finish', () => { |
| fn(...args); |
| }); |
| } |
| }; |
| }; |
| |
| // This event tells we are ready to listen for the data. |
| stream.once('response', waitForEnd((headers, flags, rawHeaders) => { |
| // If we were to emit raw request stream, it would be as fast as the native approach. |
| // Note that wrapping the raw stream in a Proxy instance won't improve the performance (already tested it). |
| const response = new IncomingMessage(this.socket, stream.readableHighWaterMark); |
| this.res = response; |
| |
| response.req = this; |
| response.statusCode = headers[HTTP2_HEADER_STATUS]; |
| response.headers = headers; |
| response.rawHeaders = rawHeaders; |
| |
| response.once('end', () => { |
| if (this.aborted) { |
| response.aborted = true; |
| response.emit('aborted'); |
| } else { |
| response.complete = true; |
| |
| // Has no effect, just be consistent with the Node.js behavior |
| response.socket = null; |
| response.connection = null; |
| } |
| }); |
| |
| if (isConnectMethod) { |
| response.upgrade = true; |
| |
| // The HTTP1 API says the socket is detached here, |
| // but we can't do that so we pass the original HTTP2 request. |
| if (this.emit('connect', response, stream, Buffer.alloc(0))) { |
| this.emit('close'); |
| } else { |
| // No listeners attached, destroy the original request. |
| stream.destroy(); |
| } |
| } else { |
| // Forwards data |
| stream.on('data', chunk => { |
| if (!response._dumped && !response.push(chunk)) { |
| stream.pause(); |
| } |
| }); |
| |
| stream.once('end', () => { |
| response.push(null); |
| }); |
| |
| if (!this.emit('response', response)) { |
| // No listeners attached, dump the response. |
| response._dump(); |
| } |
| } |
| })); |
| |
| // Emits `information` event |
| stream.once('headers', waitForEnd( |
| headers => this.emit('information', {statusCode: headers[HTTP2_HEADER_STATUS]}) |
| )); |
| |
| stream.once('trailers', waitForEnd((trailers, flags, rawTrailers) => { |
| const {res} = this; |
| |
| // Assigns trailers to the response object. |
| res.trailers = trailers; |
| res.rawTrailers = rawTrailers; |
| })); |
| |
| const {socket} = stream.session; |
| this.socket = socket; |
| this.connection = socket; |
| |
| for (const job of this[kJobs]) { |
| job(); |
| } |
| |
| this.emit('socket', this.socket); |
| }; |
| |
| // Makes a HTTP2 request |
| if (this[kSession]) { |
| try { |
| onStream(this[kSession].request(this[kHeaders])); |
| } catch (error) { |
| this.emit('error', error); |
| } |
| } else { |
| this.reusedSocket = true; |
| |
| try { |
| onStream(await this.agent.request(this[kOrigin], this[kOptions], this[kHeaders])); |
| } catch (error) { |
| this.emit('error', error); |
| } |
| } |
| } |
| |
| getHeader(name) { |
| if (typeof name !== 'string') { |
| throw new ERR_INVALID_ARG_TYPE('name', 'string', name); |
| } |
| |
| return this[kHeaders][name.toLowerCase()]; |
| } |
| |
| get headersSent() { |
| return this[kFlushedHeaders]; |
| } |
| |
| removeHeader(name) { |
| if (typeof name !== 'string') { |
| throw new ERR_INVALID_ARG_TYPE('name', 'string', name); |
| } |
| |
| if (this.headersSent) { |
| throw new ERR_HTTP_HEADERS_SENT('remove'); |
| } |
| |
| delete this[kHeaders][name.toLowerCase()]; |
| } |
| |
| setHeader(name, value) { |
| if (this.headersSent) { |
| throw new ERR_HTTP_HEADERS_SENT('set'); |
| } |
| |
| if (typeof name !== 'string' || (!isValidHttpToken.test(name) && !isRequestPseudoHeader(name))) { |
| throw new ERR_INVALID_HTTP_TOKEN('Header name', name); |
| } |
| |
| if (typeof value === 'undefined') { |
| throw new ERR_HTTP_INVALID_HEADER_VALUE(value, name); |
| } |
| |
| if (isInvalidHeaderValue.test(value)) { |
| throw new ERR_INVALID_CHAR('header content', name); |
| } |
| |
| this[kHeaders][name.toLowerCase()] = value; |
| } |
| |
| setNoDelay() { |
| // HTTP2 sockets cannot be malformed, do nothing. |
| } |
| |
| setSocketKeepAlive() { |
| // HTTP2 sockets cannot be malformed, do nothing. |
| } |
| |
| setTimeout(ms, callback) { |
| const applyTimeout = () => this._request.setTimeout(ms, callback); |
| |
| if (this._request) { |
| applyTimeout(); |
| } else { |
| this[kJobs].push(applyTimeout); |
| } |
| |
| return this; |
| } |
| |
| get maxHeadersCount() { |
| if (!this.destroyed && this._request) { |
| return this._request.session.localSettings.maxHeaderListSize; |
| } |
| |
| return undefined; |
| } |
| |
| set maxHeadersCount(_value) { |
| // Updating HTTP2 settings would affect all requests, do nothing. |
| } |
| } |
| |
| module.exports = ClientRequest; |
| |
| |
| /***/ }), |
| |
| /***/ 2575: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const {Readable} = __nccwpck_require__(2413); |
| |
| class IncomingMessage extends Readable { |
| constructor(socket, highWaterMark) { |
| super({ |
| highWaterMark, |
| autoDestroy: false |
| }); |
| |
| this.statusCode = null; |
| this.statusMessage = ''; |
| this.httpVersion = '2.0'; |
| this.httpVersionMajor = 2; |
| this.httpVersionMinor = 0; |
| this.headers = {}; |
| this.trailers = {}; |
| this.req = null; |
| |
| this.aborted = false; |
| this.complete = false; |
| this.upgrade = null; |
| |
| this.rawHeaders = []; |
| this.rawTrailers = []; |
| |
| this.socket = socket; |
| this.connection = socket; |
| |
| this._dumped = false; |
| } |
| |
| _destroy(error) { |
| this.req._request.destroy(error); |
| } |
| |
| setTimeout(ms, callback) { |
| this.req.setTimeout(ms, callback); |
| return this; |
| } |
| |
| _dump() { |
| if (!this._dumped) { |
| this._dumped = true; |
| |
| this.removeAllListeners('data'); |
| this.resume(); |
| } |
| } |
| |
| _read() { |
| if (this.req) { |
| this.req._request.resume(); |
| } |
| } |
| } |
| |
| module.exports = IncomingMessage; |
| |
| |
| /***/ }), |
| |
| /***/ 4645: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const http2 = __nccwpck_require__(7565); |
| const agent = __nccwpck_require__(9898); |
| const ClientRequest = __nccwpck_require__(9632); |
| const IncomingMessage = __nccwpck_require__(2575); |
| const auto = __nccwpck_require__(7167); |
| |
| const request = (url, options, callback) => { |
| return new ClientRequest(url, options, callback); |
| }; |
| |
| const get = (url, options, callback) => { |
| // eslint-disable-next-line unicorn/prevent-abbreviations |
| const req = new ClientRequest(url, options, callback); |
| req.end(); |
| |
| return req; |
| }; |
| |
| module.exports = { |
| ...http2, |
| ClientRequest, |
| IncomingMessage, |
| ...agent, |
| request, |
| get, |
| auto |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 1982: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const net = __nccwpck_require__(1631); |
| /* istanbul ignore file: https://github.com/nodejs/node/blob/v13.0.1/lib/_http_agent.js */ |
| |
| module.exports = options => { |
| let servername = options.host; |
| const hostHeader = options.headers && options.headers.host; |
| |
| if (hostHeader) { |
| if (hostHeader.startsWith('[')) { |
| const index = hostHeader.indexOf(']'); |
| if (index === -1) { |
| servername = hostHeader; |
| } else { |
| servername = hostHeader.slice(1, -1); |
| } |
| } else { |
| servername = hostHeader.split(':', 1)[0]; |
| } |
| } |
| |
| if (net.isIP(servername)) { |
| return ''; |
| } |
| |
| return servername; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 7087: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| /* istanbul ignore file: https://github.com/nodejs/node/blob/master/lib/internal/errors.js */ |
| |
| const makeError = (Base, key, getMessage) => { |
| module.exports[key] = class NodeError extends Base { |
| constructor(...args) { |
| super(typeof getMessage === 'string' ? getMessage : getMessage(args)); |
| this.name = `${super.name} [${key}]`; |
| this.code = key; |
| } |
| }; |
| }; |
| |
| makeError(TypeError, 'ERR_INVALID_ARG_TYPE', args => { |
| const type = args[0].includes('.') ? 'property' : 'argument'; |
| |
| let valid = args[1]; |
| const isManyTypes = Array.isArray(valid); |
| |
| if (isManyTypes) { |
| valid = `${valid.slice(0, -1).join(', ')} or ${valid.slice(-1)}`; |
| } |
| |
| return `The "${args[0]}" ${type} must be ${isManyTypes ? 'one of' : 'of'} type ${valid}. Received ${typeof args[2]}`; |
| }); |
| |
| makeError(TypeError, 'ERR_INVALID_PROTOCOL', args => { |
| return `Protocol "${args[0]}" not supported. Expected "${args[1]}"`; |
| }); |
| |
| makeError(Error, 'ERR_HTTP_HEADERS_SENT', args => { |
| return `Cannot ${args[0]} headers after they are sent to the client`; |
| }); |
| |
| makeError(TypeError, 'ERR_INVALID_HTTP_TOKEN', args => { |
| return `${args[0]} must be a valid HTTP token [${args[1]}]`; |
| }); |
| |
| makeError(TypeError, 'ERR_HTTP_INVALID_HEADER_VALUE', args => { |
| return `Invalid value "${args[0]} for header "${args[1]}"`; |
| }); |
| |
| makeError(TypeError, 'ERR_INVALID_CHAR', args => { |
| return `Invalid character in ${args[0]} [${args[1]}]`; |
| }); |
| |
| |
| /***/ }), |
| |
| /***/ 1199: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| module.exports = header => { |
| switch (header) { |
| case ':method': |
| case ':scheme': |
| case ':authority': |
| case ':path': |
| return true; |
| default: |
| return false; |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 1818: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| module.exports = (from, to, events) => { |
| for (const event of events) { |
| from.on(event, (...args) => to.emit(event, ...args)); |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 2686: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| /* istanbul ignore file: https://github.com/nodejs/node/blob/a91293d4d9ab403046ab5eb022332e4e3d249bd3/lib/internal/url.js#L1257 */ |
| |
| module.exports = url => { |
| const options = { |
| protocol: url.protocol, |
| hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname, |
| host: url.host, |
| hash: url.hash, |
| search: url.search, |
| pathname: url.pathname, |
| href: url.href, |
| path: `${url.pathname || ''}${url.search || ''}` |
| }; |
| |
| if (typeof url.port === 'string' && url.port.length !== 0) { |
| options.port = Number(url.port); |
| } |
| |
| if (url.username || url.password) { |
| options.auth = `${url.username || ''}:${url.password || ''}`; |
| } |
| |
| return options; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 6435: |
| /***/ ((module) => { |
| |
| /*! |
| * is-extglob <https://github.com/jonschlinkert/is-extglob> |
| * |
| * Copyright (c) 2014-2016, Jon Schlinkert. |
| * Licensed under the MIT License. |
| */ |
| |
| module.exports = function isExtglob(str) { |
| if (typeof str !== 'string' || str === '') { |
| return false; |
| } |
| |
| var match; |
| while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) { |
| if (match[2]) return true; |
| str = str.slice(match.index + match[0].length); |
| } |
| |
| return false; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 4466: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| /*! |
| * is-glob <https://github.com/jonschlinkert/is-glob> |
| * |
| * Copyright (c) 2014-2017, Jon Schlinkert. |
| * Released under the MIT License. |
| */ |
| |
| var isExtglob = __nccwpck_require__(6435); |
| var chars = { '{': '}', '(': ')', '[': ']'}; |
| var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/; |
| var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/; |
| |
| module.exports = function isGlob(str, options) { |
| if (typeof str !== 'string' || str === '') { |
| return false; |
| } |
| |
| if (isExtglob(str)) { |
| return true; |
| } |
| |
| var regex = strictRegex; |
| var match; |
| |
| // optionally relax regex |
| if (options && options.strict === false) { |
| regex = relaxedRegex; |
| } |
| |
| while ((match = regex.exec(str))) { |
| if (match[2]) return true; |
| var idx = match.index + match[0].length; |
| |
| // if an open bracket/brace/paren is escaped, |
| // set the index to the next closing character |
| var open = match[1]; |
| var close = open ? chars[open] : null; |
| if (open && close) { |
| var n = str.indexOf(close, idx); |
| if (n !== -1) { |
| idx = n + 1; |
| } |
| } |
| |
| str = str.slice(idx); |
| } |
| return false; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 2820: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| //TODO: handle reviver/dehydrate function like normal |
| //and handle indentation, like normal. |
| //if anyone needs this... please send pull request. |
| |
| exports.stringify = function stringify (o) { |
| if('undefined' == typeof o) return o |
| |
| if(o && Buffer.isBuffer(o)) |
| return JSON.stringify(':base64:' + o.toString('base64')) |
| |
| if(o && o.toJSON) |
| o = o.toJSON() |
| |
| if(o && 'object' === typeof o) { |
| var s = '' |
| var array = Array.isArray(o) |
| s = array ? '[' : '{' |
| var first = true |
| |
| for(var k in o) { |
| var ignore = 'function' == typeof o[k] || (!array && 'undefined' === typeof o[k]) |
| if(Object.hasOwnProperty.call(o, k) && !ignore) { |
| if(!first) |
| s += ',' |
| first = false |
| if (array) { |
| if(o[k] == undefined) |
| s += 'null' |
| else |
| s += stringify(o[k]) |
| } else if (o[k] !== void(0)) { |
| s += stringify(k) + ':' + stringify(o[k]) |
| } |
| } |
| } |
| |
| s += array ? ']' : '}' |
| |
| return s |
| } else if ('string' === typeof o) { |
| return JSON.stringify(/^:/.test(o) ? ':' + o : o) |
| } else if ('undefined' === typeof o) { |
| return 'null'; |
| } else |
| return JSON.stringify(o) |
| } |
| |
| exports.parse = function (s) { |
| return JSON.parse(s, function (key, value) { |
| if('string' === typeof value) { |
| if(/^:base64:/.test(value)) |
| return Buffer.from(value.substring(8), 'base64') |
| else |
| return /^:/.test(value) ? value.substring(1) : value |
| } |
| return value |
| }) |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 1531: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const EventEmitter = __nccwpck_require__(8614); |
| const JSONB = __nccwpck_require__(2820); |
| |
| const loadStore = opts => { |
| const adapters = { |
| redis: '@keyv/redis', |
| mongodb: '@keyv/mongo', |
| mongo: '@keyv/mongo', |
| sqlite: '@keyv/sqlite', |
| postgresql: '@keyv/postgres', |
| postgres: '@keyv/postgres', |
| mysql: '@keyv/mysql' |
| }; |
| if (opts.adapter || opts.uri) { |
| const adapter = opts.adapter || /^[^:]*/.exec(opts.uri)[0]; |
| return new (require(adapters[adapter]))(opts); |
| } |
| |
| return new Map(); |
| }; |
| |
| class Keyv extends EventEmitter { |
| constructor(uri, opts) { |
| super(); |
| this.opts = Object.assign( |
| { |
| namespace: 'keyv', |
| serialize: JSONB.stringify, |
| deserialize: JSONB.parse |
| }, |
| (typeof uri === 'string') ? { uri } : uri, |
| opts |
| ); |
| |
| if (!this.opts.store) { |
| const adapterOpts = Object.assign({}, this.opts); |
| this.opts.store = loadStore(adapterOpts); |
| } |
| |
| if (typeof this.opts.store.on === 'function') { |
| this.opts.store.on('error', err => this.emit('error', err)); |
| } |
| |
| this.opts.store.namespace = this.opts.namespace; |
| } |
| |
| _getKeyPrefix(key) { |
| return `${this.opts.namespace}:${key}`; |
| } |
| |
| get(key, opts) { |
| const keyPrefixed = this._getKeyPrefix(key); |
| const { store } = this.opts; |
| return Promise.resolve() |
| .then(() => store.get(keyPrefixed)) |
| .then(data => { |
| return (typeof data === 'string') ? this.opts.deserialize(data) : data; |
| }) |
| .then(data => { |
| if (data === undefined) { |
| return undefined; |
| } |
| |
| if (typeof data.expires === 'number' && Date.now() > data.expires) { |
| this.delete(key); |
| return undefined; |
| } |
| |
| return (opts && opts.raw) ? data : data.value; |
| }); |
| } |
| |
| set(key, value, ttl) { |
| const keyPrefixed = this._getKeyPrefix(key); |
| if (typeof ttl === 'undefined') { |
| ttl = this.opts.ttl; |
| } |
| |
| if (ttl === 0) { |
| ttl = undefined; |
| } |
| |
| const { store } = this.opts; |
| |
| return Promise.resolve() |
| .then(() => { |
| const expires = (typeof ttl === 'number') ? (Date.now() + ttl) : null; |
| value = { value, expires }; |
| return this.opts.serialize(value); |
| }) |
| .then(value => store.set(keyPrefixed, value, ttl)) |
| .then(() => true); |
| } |
| |
| delete(key) { |
| const keyPrefixed = this._getKeyPrefix(key); |
| const { store } = this.opts; |
| return Promise.resolve() |
| .then(() => store.delete(keyPrefixed)); |
| } |
| |
| clear() { |
| const { store } = this.opts; |
| return Promise.resolve() |
| .then(() => store.clear()); |
| } |
| } |
| |
| module.exports = Keyv; |
| |
| |
| /***/ }), |
| |
| /***/ 9662: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| module.exports = object => { |
| const result = {}; |
| |
| for (const [key, value] of Object.entries(object)) { |
| result[key.toLowerCase()] = value; |
| } |
| |
| return result; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 2578: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| /* |
| * merge2 |
| * https://github.com/teambition/merge2 |
| * |
| * Copyright (c) 2014-2020 Teambition |
| * Licensed under the MIT license. |
| */ |
| const Stream = __nccwpck_require__(2413) |
| const PassThrough = Stream.PassThrough |
| const slice = Array.prototype.slice |
| |
| module.exports = merge2 |
| |
| function merge2 () { |
| const streamsQueue = [] |
| const args = slice.call(arguments) |
| let merging = false |
| let options = args[args.length - 1] |
| |
| if (options && !Array.isArray(options) && options.pipe == null) { |
| args.pop() |
| } else { |
| options = {} |
| } |
| |
| const doEnd = options.end !== false |
| const doPipeError = options.pipeError === true |
| if (options.objectMode == null) { |
| options.objectMode = true |
| } |
| if (options.highWaterMark == null) { |
| options.highWaterMark = 64 * 1024 |
| } |
| const mergedStream = PassThrough(options) |
| |
| function addStream () { |
| for (let i = 0, len = arguments.length; i < len; i++) { |
| streamsQueue.push(pauseStreams(arguments[i], options)) |
| } |
| mergeStream() |
| return this |
| } |
| |
| function mergeStream () { |
| if (merging) { |
| return |
| } |
| merging = true |
| |
| let streams = streamsQueue.shift() |
| if (!streams) { |
| process.nextTick(endStream) |
| return |
| } |
| if (!Array.isArray(streams)) { |
| streams = [streams] |
| } |
| |
| let pipesCount = streams.length + 1 |
| |
| function next () { |
| if (--pipesCount > 0) { |
| return |
| } |
| merging = false |
| mergeStream() |
| } |
| |
| function pipe (stream) { |
| function onend () { |
| stream.removeListener('merge2UnpipeEnd', onend) |
| stream.removeListener('end', onend) |
| if (doPipeError) { |
| stream.removeListener('error', onerror) |
| } |
| next() |
| } |
| function onerror (err) { |
| mergedStream.emit('error', err) |
| } |
| // skip ended stream |
| if (stream._readableState.endEmitted) { |
| return next() |
| } |
| |
| stream.on('merge2UnpipeEnd', onend) |
| stream.on('end', onend) |
| |
| if (doPipeError) { |
| stream.on('error', onerror) |
| } |
| |
| stream.pipe(mergedStream, { end: false }) |
| // compatible for old stream |
| stream.resume() |
| } |
| |
| for (let i = 0; i < streams.length; i++) { |
| pipe(streams[i]) |
| } |
| |
| next() |
| } |
| |
| function endStream () { |
| merging = false |
| // emit 'queueDrain' when all streams merged. |
| mergedStream.emit('queueDrain') |
| if (doEnd) { |
| mergedStream.end() |
| } |
| } |
| |
| mergedStream.setMaxListeners(0) |
| mergedStream.add = addStream |
| mergedStream.on('unpipe', function (stream) { |
| stream.emit('merge2UnpipeEnd') |
| }) |
| |
| if (args.length) { |
| addStream.apply(null, args) |
| } |
| return mergedStream |
| } |
| |
| // check and pause streams for pipe. |
| function pauseStreams (streams, options) { |
| if (!Array.isArray(streams)) { |
| // Backwards-compat with old-style streams |
| if (!streams._readableState && streams.pipe) { |
| streams = streams.pipe(PassThrough(options)) |
| } |
| if (!streams._readableState || !streams.pause || !streams.pipe) { |
| throw new Error('Only readable stream can be merged.') |
| } |
| streams.pause() |
| } else { |
| for (let i = 0, len = streams.length; i < len; i++) { |
| streams[i] = pauseStreams(streams[i], options) |
| } |
| } |
| return streams |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2610: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| // We define these manually to ensure they're always copied |
| // even if they would move up the prototype chain |
| // https://nodejs.org/api/http.html#http_class_http_incomingmessage |
| const knownProps = [ |
| 'destroy', |
| 'setTimeout', |
| 'socket', |
| 'headers', |
| 'trailers', |
| 'rawHeaders', |
| 'statusCode', |
| 'httpVersion', |
| 'httpVersionMinor', |
| 'httpVersionMajor', |
| 'rawTrailers', |
| 'statusMessage' |
| ]; |
| |
| module.exports = (fromStream, toStream) => { |
| const fromProps = new Set(Object.keys(fromStream).concat(knownProps)); |
| |
| for (const prop of fromProps) { |
| // Don't overwrite existing properties |
| if (prop in toStream) { |
| continue; |
| } |
| |
| toStream[prop] = typeof fromStream[prop] === 'function' ? fromStream[prop].bind(fromStream) : fromStream[prop]; |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 467: |
| /***/ ((module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } |
| |
| var Stream = _interopDefault(__nccwpck_require__(2413)); |
| var http = _interopDefault(__nccwpck_require__(8605)); |
| var Url = _interopDefault(__nccwpck_require__(8835)); |
| var https = _interopDefault(__nccwpck_require__(7211)); |
| var zlib = _interopDefault(__nccwpck_require__(8761)); |
| |
| // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js |
| |
| // fix for "Readable" isn't a named export issue |
| const Readable = Stream.Readable; |
| |
| const BUFFER = Symbol('buffer'); |
| const TYPE = Symbol('type'); |
| |
| class Blob { |
| constructor() { |
| this[TYPE] = ''; |
| |
| const blobParts = arguments[0]; |
| const options = arguments[1]; |
| |
| const buffers = []; |
| let size = 0; |
| |
| if (blobParts) { |
| const a = blobParts; |
| const length = Number(a.length); |
| for (let i = 0; i < length; i++) { |
| const element = a[i]; |
| let buffer; |
| if (element instanceof Buffer) { |
| buffer = element; |
| } else if (ArrayBuffer.isView(element)) { |
| buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); |
| } else if (element instanceof ArrayBuffer) { |
| buffer = Buffer.from(element); |
| } else if (element instanceof Blob) { |
| buffer = element[BUFFER]; |
| } else { |
| buffer = Buffer.from(typeof element === 'string' ? element : String(element)); |
| } |
| size += buffer.length; |
| buffers.push(buffer); |
| } |
| } |
| |
| this[BUFFER] = Buffer.concat(buffers); |
| |
| let type = options && options.type !== undefined && String(options.type).toLowerCase(); |
| if (type && !/[^\u0020-\u007E]/.test(type)) { |
| this[TYPE] = type; |
| } |
| } |
| get size() { |
| return this[BUFFER].length; |
| } |
| get type() { |
| return this[TYPE]; |
| } |
| text() { |
| return Promise.resolve(this[BUFFER].toString()); |
| } |
| arrayBuffer() { |
| const buf = this[BUFFER]; |
| const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); |
| return Promise.resolve(ab); |
| } |
| stream() { |
| const readable = new Readable(); |
| readable._read = function () {}; |
| readable.push(this[BUFFER]); |
| readable.push(null); |
| return readable; |
| } |
| toString() { |
| return '[object Blob]'; |
| } |
| slice() { |
| const size = this.size; |
| |
| const start = arguments[0]; |
| const end = arguments[1]; |
| let relativeStart, relativeEnd; |
| if (start === undefined) { |
| relativeStart = 0; |
| } else if (start < 0) { |
| relativeStart = Math.max(size + start, 0); |
| } else { |
| relativeStart = Math.min(start, size); |
| } |
| if (end === undefined) { |
| relativeEnd = size; |
| } else if (end < 0) { |
| relativeEnd = Math.max(size + end, 0); |
| } else { |
| relativeEnd = Math.min(end, size); |
| } |
| const span = Math.max(relativeEnd - relativeStart, 0); |
| |
| const buffer = this[BUFFER]; |
| const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); |
| const blob = new Blob([], { type: arguments[2] }); |
| blob[BUFFER] = slicedBuffer; |
| return blob; |
| } |
| } |
| |
| Object.defineProperties(Blob.prototype, { |
| size: { enumerable: true }, |
| type: { enumerable: true }, |
| slice: { enumerable: true } |
| }); |
| |
| Object.defineProperty(Blob.prototype, Symbol.toStringTag, { |
| value: 'Blob', |
| writable: false, |
| enumerable: false, |
| configurable: true |
| }); |
| |
| /** |
| * fetch-error.js |
| * |
| * FetchError interface for operational errors |
| */ |
| |
| /** |
| * Create FetchError instance |
| * |
| * @param String message Error message for human |
| * @param String type Error type for machine |
| * @param String systemError For Node.js system error |
| * @return FetchError |
| */ |
| function FetchError(message, type, systemError) { |
| Error.call(this, message); |
| |
| this.message = message; |
| this.type = type; |
| |
| // when err.type is `system`, err.code contains system error code |
| if (systemError) { |
| this.code = this.errno = systemError.code; |
| } |
| |
| // hide custom error implementation details from end-users |
| Error.captureStackTrace(this, this.constructor); |
| } |
| |
| FetchError.prototype = Object.create(Error.prototype); |
| FetchError.prototype.constructor = FetchError; |
| FetchError.prototype.name = 'FetchError'; |
| |
| let convert; |
| try { |
| convert = __nccwpck_require__(2877).convert; |
| } catch (e) {} |
| |
| const INTERNALS = Symbol('Body internals'); |
| |
| // fix an issue where "PassThrough" isn't a named export for node <10 |
| const PassThrough = Stream.PassThrough; |
| |
| /** |
| * Body mixin |
| * |
| * Ref: https://fetch.spec.whatwg.org/#body |
| * |
| * @param Stream body Readable stream |
| * @param Object opts Response options |
| * @return Void |
| */ |
| function Body(body) { |
| var _this = this; |
| |
| var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, |
| _ref$size = _ref.size; |
| |
| let size = _ref$size === undefined ? 0 : _ref$size; |
| var _ref$timeout = _ref.timeout; |
| let timeout = _ref$timeout === undefined ? 0 : _ref$timeout; |
| |
| if (body == null) { |
| // body is undefined or null |
| body = null; |
| } else if (isURLSearchParams(body)) { |
| // body is a URLSearchParams |
| body = Buffer.from(body.toString()); |
| } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { |
| // body is ArrayBuffer |
| body = Buffer.from(body); |
| } else if (ArrayBuffer.isView(body)) { |
| // body is ArrayBufferView |
| body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); |
| } else if (body instanceof Stream) ; else { |
| // none of the above |
| // coerce to string then buffer |
| body = Buffer.from(String(body)); |
| } |
| this[INTERNALS] = { |
| body, |
| disturbed: false, |
| error: null |
| }; |
| this.size = size; |
| this.timeout = timeout; |
| |
| if (body instanceof Stream) { |
| body.on('error', function (err) { |
| const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err); |
| _this[INTERNALS].error = error; |
| }); |
| } |
| } |
| |
| Body.prototype = { |
| get body() { |
| return this[INTERNALS].body; |
| }, |
| |
| get bodyUsed() { |
| return this[INTERNALS].disturbed; |
| }, |
| |
| /** |
| * Decode response as ArrayBuffer |
| * |
| * @return Promise |
| */ |
| arrayBuffer() { |
| return consumeBody.call(this).then(function (buf) { |
| return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); |
| }); |
| }, |
| |
| /** |
| * Return raw response as Blob |
| * |
| * @return Promise |
| */ |
| blob() { |
| let ct = this.headers && this.headers.get('content-type') || ''; |
| return consumeBody.call(this).then(function (buf) { |
| return Object.assign( |
| // Prevent copying |
| new Blob([], { |
| type: ct.toLowerCase() |
| }), { |
| [BUFFER]: buf |
| }); |
| }); |
| }, |
| |
| /** |
| * Decode response as json |
| * |
| * @return Promise |
| */ |
| json() { |
| var _this2 = this; |
| |
| return consumeBody.call(this).then(function (buffer) { |
| try { |
| return JSON.parse(buffer.toString()); |
| } catch (err) { |
| return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json')); |
| } |
| }); |
| }, |
| |
| /** |
| * Decode response as text |
| * |
| * @return Promise |
| */ |
| text() { |
| return consumeBody.call(this).then(function (buffer) { |
| return buffer.toString(); |
| }); |
| }, |
| |
| /** |
| * Decode response as buffer (non-spec api) |
| * |
| * @return Promise |
| */ |
| buffer() { |
| return consumeBody.call(this); |
| }, |
| |
| /** |
| * Decode response as text, while automatically detecting the encoding and |
| * trying to decode to UTF-8 (non-spec api) |
| * |
| * @return Promise |
| */ |
| textConverted() { |
| var _this3 = this; |
| |
| return consumeBody.call(this).then(function (buffer) { |
| return convertBody(buffer, _this3.headers); |
| }); |
| } |
| }; |
| |
| // In browsers, all properties are enumerable. |
| Object.defineProperties(Body.prototype, { |
| body: { enumerable: true }, |
| bodyUsed: { enumerable: true }, |
| arrayBuffer: { enumerable: true }, |
| blob: { enumerable: true }, |
| json: { enumerable: true }, |
| text: { enumerable: true } |
| }); |
| |
| Body.mixIn = function (proto) { |
| for (const name of Object.getOwnPropertyNames(Body.prototype)) { |
| // istanbul ignore else: future proof |
| if (!(name in proto)) { |
| const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); |
| Object.defineProperty(proto, name, desc); |
| } |
| } |
| }; |
| |
| /** |
| * Consume and convert an entire Body to a Buffer. |
| * |
| * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body |
| * |
| * @return Promise |
| */ |
| function consumeBody() { |
| var _this4 = this; |
| |
| if (this[INTERNALS].disturbed) { |
| return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); |
| } |
| |
| this[INTERNALS].disturbed = true; |
| |
| if (this[INTERNALS].error) { |
| return Body.Promise.reject(this[INTERNALS].error); |
| } |
| |
| let body = this.body; |
| |
| // body is null |
| if (body === null) { |
| return Body.Promise.resolve(Buffer.alloc(0)); |
| } |
| |
| // body is blob |
| if (isBlob(body)) { |
| body = body.stream(); |
| } |
| |
| // body is buffer |
| if (Buffer.isBuffer(body)) { |
| return Body.Promise.resolve(body); |
| } |
| |
| // istanbul ignore if: should never happen |
| if (!(body instanceof Stream)) { |
| return Body.Promise.resolve(Buffer.alloc(0)); |
| } |
| |
| // body is stream |
| // get ready to actually consume the body |
| let accum = []; |
| let accumBytes = 0; |
| let abort = false; |
| |
| return new Body.Promise(function (resolve, reject) { |
| let resTimeout; |
| |
| // allow timeout on slow response body |
| if (_this4.timeout) { |
| resTimeout = setTimeout(function () { |
| abort = true; |
| reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout')); |
| }, _this4.timeout); |
| } |
| |
| // handle stream errors |
| body.on('error', function (err) { |
| if (err.name === 'AbortError') { |
| // if the request was aborted, reject with this Error |
| abort = true; |
| reject(err); |
| } else { |
| // other errors, such as incorrect content-encoding |
| reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err)); |
| } |
| }); |
| |
| body.on('data', function (chunk) { |
| if (abort || chunk === null) { |
| return; |
| } |
| |
| if (_this4.size && accumBytes + chunk.length > _this4.size) { |
| abort = true; |
| reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size')); |
| return; |
| } |
| |
| accumBytes += chunk.length; |
| accum.push(chunk); |
| }); |
| |
| body.on('end', function () { |
| if (abort) { |
| return; |
| } |
| |
| clearTimeout(resTimeout); |
| |
| try { |
| resolve(Buffer.concat(accum, accumBytes)); |
| } catch (err) { |
| // handle streams that have accumulated too much data (issue #414) |
| reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err)); |
| } |
| }); |
| }); |
| } |
| |
| /** |
| * Detect buffer encoding and convert to target encoding |
| * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding |
| * |
| * @param Buffer buffer Incoming buffer |
| * @param String encoding Target encoding |
| * @return String |
| */ |
| function convertBody(buffer, headers) { |
| if (typeof convert !== 'function') { |
| throw new Error('The package `encoding` must be installed to use the textConverted() function'); |
| } |
| |
| const ct = headers.get('content-type'); |
| let charset = 'utf-8'; |
| let res, str; |
| |
| // header |
| if (ct) { |
| res = /charset=([^;]*)/i.exec(ct); |
| } |
| |
| // no charset in content type, peek at response body for at most 1024 bytes |
| str = buffer.slice(0, 1024).toString(); |
| |
| // html5 |
| if (!res && str) { |
| res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str); |
| } |
| |
| // html4 |
| if (!res && str) { |
| res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str); |
| if (!res) { |
| res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str); |
| if (res) { |
| res.pop(); // drop last quote |
| } |
| } |
| |
| if (res) { |
| res = /charset=(.*)/i.exec(res.pop()); |
| } |
| } |
| |
| // xml |
| if (!res && str) { |
| res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str); |
| } |
| |
| // found charset |
| if (res) { |
| charset = res.pop(); |
| |
| // prevent decode issues when sites use incorrect encoding |
| // ref: https://hsivonen.fi/encoding-menu/ |
| if (charset === 'gb2312' || charset === 'gbk') { |
| charset = 'gb18030'; |
| } |
| } |
| |
| // turn raw buffers into a single utf-8 buffer |
| return convert(buffer, 'UTF-8', charset).toString(); |
| } |
| |
| /** |
| * Detect a URLSearchParams object |
| * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143 |
| * |
| * @param Object obj Object to detect by type or brand |
| * @return String |
| */ |
| function isURLSearchParams(obj) { |
| // Duck-typing as a necessary condition. |
| if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') { |
| return false; |
| } |
| |
| // Brand-checking and more duck-typing as optional condition. |
| return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function'; |
| } |
| |
| /** |
| * Check if `obj` is a W3C `Blob` object (which `File` inherits from) |
| * @param {*} obj |
| * @return {boolean} |
| */ |
| function isBlob(obj) { |
| return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]); |
| } |
| |
| /** |
| * Clone body given Res/Req instance |
| * |
| * @param Mixed instance Response or Request instance |
| * @return Mixed |
| */ |
| function clone(instance) { |
| let p1, p2; |
| let body = instance.body; |
| |
| // don't allow cloning a used body |
| if (instance.bodyUsed) { |
| throw new Error('cannot clone body after it is used'); |
| } |
| |
| // check that body is a stream and not form-data object |
| // note: we can't clone the form-data object without having it as a dependency |
| if (body instanceof Stream && typeof body.getBoundary !== 'function') { |
| // tee instance body |
| p1 = new PassThrough(); |
| p2 = new PassThrough(); |
| body.pipe(p1); |
| body.pipe(p2); |
| // set instance body to teed body and return the other teed body |
| instance[INTERNALS].body = p1; |
| body = p2; |
| } |
| |
| return body; |
| } |
| |
| /** |
| * Performs the operation "extract a `Content-Type` value from |object|" as |
| * specified in the specification: |
| * https://fetch.spec.whatwg.org/#concept-bodyinit-extract |
| * |
| * This function assumes that instance.body is present. |
| * |
| * @param Mixed instance Any options.body input |
| */ |
| function extractContentType(body) { |
| if (body === null) { |
| // body is null |
| return null; |
| } else if (typeof body === 'string') { |
| // body is string |
| return 'text/plain;charset=UTF-8'; |
| } else if (isURLSearchParams(body)) { |
| // body is a URLSearchParams |
| return 'application/x-www-form-urlencoded;charset=UTF-8'; |
| } else if (isBlob(body)) { |
| // body is blob |
| return body.type || null; |
| } else if (Buffer.isBuffer(body)) { |
| // body is buffer |
| return null; |
| } else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { |
| // body is ArrayBuffer |
| return null; |
| } else if (ArrayBuffer.isView(body)) { |
| // body is ArrayBufferView |
| return null; |
| } else if (typeof body.getBoundary === 'function') { |
| // detect form data input from form-data module |
| return `multipart/form-data;boundary=${body.getBoundary()}`; |
| } else if (body instanceof Stream) { |
| // body is stream |
| // can't really do much about this |
| return null; |
| } else { |
| // Body constructor defaults other things to string |
| return 'text/plain;charset=UTF-8'; |
| } |
| } |
| |
| /** |
| * The Fetch Standard treats this as if "total bytes" is a property on the body. |
| * For us, we have to explicitly get it with a function. |
| * |
| * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes |
| * |
| * @param Body instance Instance of Body |
| * @return Number? Number of bytes, or null if not possible |
| */ |
| function getTotalBytes(instance) { |
| const body = instance.body; |
| |
| |
| if (body === null) { |
| // body is null |
| return 0; |
| } else if (isBlob(body)) { |
| return body.size; |
| } else if (Buffer.isBuffer(body)) { |
| // body is buffer |
| return body.length; |
| } else if (body && typeof body.getLengthSync === 'function') { |
| // detect form data input from form-data module |
| if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x |
| body.hasKnownLength && body.hasKnownLength()) { |
| // 2.x |
| return body.getLengthSync(); |
| } |
| return null; |
| } else { |
| // body is stream |
| return null; |
| } |
| } |
| |
| /** |
| * Write a Body to a Node.js WritableStream (e.g. http.Request) object. |
| * |
| * @param Body instance Instance of Body |
| * @return Void |
| */ |
| function writeToStream(dest, instance) { |
| const body = instance.body; |
| |
| |
| if (body === null) { |
| // body is null |
| dest.end(); |
| } else if (isBlob(body)) { |
| body.stream().pipe(dest); |
| } else if (Buffer.isBuffer(body)) { |
| // body is buffer |
| dest.write(body); |
| dest.end(); |
| } else { |
| // body is stream |
| body.pipe(dest); |
| } |
| } |
| |
| // expose Promise |
| Body.Promise = global.Promise; |
| |
| /** |
| * headers.js |
| * |
| * Headers class offers convenient helpers |
| */ |
| |
| const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/; |
| const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/; |
| |
| function validateName(name) { |
| name = `${name}`; |
| if (invalidTokenRegex.test(name) || name === '') { |
| throw new TypeError(`${name} is not a legal HTTP header name`); |
| } |
| } |
| |
| function validateValue(value) { |
| value = `${value}`; |
| if (invalidHeaderCharRegex.test(value)) { |
| throw new TypeError(`${value} is not a legal HTTP header value`); |
| } |
| } |
| |
| /** |
| * Find the key in the map object given a header name. |
| * |
| * Returns undefined if not found. |
| * |
| * @param String name Header name |
| * @return String|Undefined |
| */ |
| function find(map, name) { |
| name = name.toLowerCase(); |
| for (const key in map) { |
| if (key.toLowerCase() === name) { |
| return key; |
| } |
| } |
| return undefined; |
| } |
| |
| const MAP = Symbol('map'); |
| class Headers { |
| /** |
| * Headers class |
| * |
| * @param Object headers Response headers |
| * @return Void |
| */ |
| constructor() { |
| let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined; |
| |
| this[MAP] = Object.create(null); |
| |
| if (init instanceof Headers) { |
| const rawHeaders = init.raw(); |
| const headerNames = Object.keys(rawHeaders); |
| |
| for (const headerName of headerNames) { |
| for (const value of rawHeaders[headerName]) { |
| this.append(headerName, value); |
| } |
| } |
| |
| return; |
| } |
| |
| // We don't worry about converting prop to ByteString here as append() |
| // will handle it. |
| if (init == null) ; else if (typeof init === 'object') { |
| const method = init[Symbol.iterator]; |
| if (method != null) { |
| if (typeof method !== 'function') { |
| throw new TypeError('Header pairs must be iterable'); |
| } |
| |
| // sequence<sequence<ByteString>> |
| // Note: per spec we have to first exhaust the lists then process them |
| const pairs = []; |
| for (const pair of init) { |
| if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') { |
| throw new TypeError('Each header pair must be iterable'); |
| } |
| pairs.push(Array.from(pair)); |
| } |
| |
| for (const pair of pairs) { |
| if (pair.length !== 2) { |
| throw new TypeError('Each header pair must be a name/value tuple'); |
| } |
| this.append(pair[0], pair[1]); |
| } |
| } else { |
| // record<ByteString, ByteString> |
| for (const key of Object.keys(init)) { |
| const value = init[key]; |
| this.append(key, value); |
| } |
| } |
| } else { |
| throw new TypeError('Provided initializer must be an object'); |
| } |
| } |
| |
| /** |
| * Return combined header value given name |
| * |
| * @param String name Header name |
| * @return Mixed |
| */ |
| get(name) { |
| name = `${name}`; |
| validateName(name); |
| const key = find(this[MAP], name); |
| if (key === undefined) { |
| return null; |
| } |
| |
| return this[MAP][key].join(', '); |
| } |
| |
| /** |
| * Iterate over all headers |
| * |
| * @param Function callback Executed for each item with parameters (value, name, thisArg) |
| * @param Boolean thisArg `this` context for callback function |
| * @return Void |
| */ |
| forEach(callback) { |
| let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; |
| |
| let pairs = getHeaders(this); |
| let i = 0; |
| while (i < pairs.length) { |
| var _pairs$i = pairs[i]; |
| const name = _pairs$i[0], |
| value = _pairs$i[1]; |
| |
| callback.call(thisArg, value, name, this); |
| pairs = getHeaders(this); |
| i++; |
| } |
| } |
| |
| /** |
| * Overwrite header values given name |
| * |
| * @param String name Header name |
| * @param String value Header value |
| * @return Void |
| */ |
| set(name, value) { |
| name = `${name}`; |
| value = `${value}`; |
| validateName(name); |
| validateValue(value); |
| const key = find(this[MAP], name); |
| this[MAP][key !== undefined ? key : name] = [value]; |
| } |
| |
| /** |
| * Append a value onto existing header |
| * |
| * @param String name Header name |
| * @param String value Header value |
| * @return Void |
| */ |
| append(name, value) { |
| name = `${name}`; |
| value = `${value}`; |
| validateName(name); |
| validateValue(value); |
| const key = find(this[MAP], name); |
| if (key !== undefined) { |
| this[MAP][key].push(value); |
| } else { |
| this[MAP][name] = [value]; |
| } |
| } |
| |
| /** |
| * Check for header name existence |
| * |
| * @param String name Header name |
| * @return Boolean |
| */ |
| has(name) { |
| name = `${name}`; |
| validateName(name); |
| return find(this[MAP], name) !== undefined; |
| } |
| |
| /** |
| * Delete all header values given name |
| * |
| * @param String name Header name |
| * @return Void |
| */ |
| delete(name) { |
| name = `${name}`; |
| validateName(name); |
| const key = find(this[MAP], name); |
| if (key !== undefined) { |
| delete this[MAP][key]; |
| } |
| } |
| |
| /** |
| * Return raw headers (non-spec api) |
| * |
| * @return Object |
| */ |
| raw() { |
| return this[MAP]; |
| } |
| |
| /** |
| * Get an iterator on keys. |
| * |
| * @return Iterator |
| */ |
| keys() { |
| return createHeadersIterator(this, 'key'); |
| } |
| |
| /** |
| * Get an iterator on values. |
| * |
| * @return Iterator |
| */ |
| values() { |
| return createHeadersIterator(this, 'value'); |
| } |
| |
| /** |
| * Get an iterator on entries. |
| * |
| * This is the default iterator of the Headers object. |
| * |
| * @return Iterator |
| */ |
| [Symbol.iterator]() { |
| return createHeadersIterator(this, 'key+value'); |
| } |
| } |
| Headers.prototype.entries = Headers.prototype[Symbol.iterator]; |
| |
| Object.defineProperty(Headers.prototype, Symbol.toStringTag, { |
| value: 'Headers', |
| writable: false, |
| enumerable: false, |
| configurable: true |
| }); |
| |
| Object.defineProperties(Headers.prototype, { |
| get: { enumerable: true }, |
| forEach: { enumerable: true }, |
| set: { enumerable: true }, |
| append: { enumerable: true }, |
| has: { enumerable: true }, |
| delete: { enumerable: true }, |
| keys: { enumerable: true }, |
| values: { enumerable: true }, |
| entries: { enumerable: true } |
| }); |
| |
| function getHeaders(headers) { |
| let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value'; |
| |
| const keys = Object.keys(headers[MAP]).sort(); |
| return keys.map(kind === 'key' ? function (k) { |
| return k.toLowerCase(); |
| } : kind === 'value' ? function (k) { |
| return headers[MAP][k].join(', '); |
| } : function (k) { |
| return [k.toLowerCase(), headers[MAP][k].join(', ')]; |
| }); |
| } |
| |
| const INTERNAL = Symbol('internal'); |
| |
| function createHeadersIterator(target, kind) { |
| const iterator = Object.create(HeadersIteratorPrototype); |
| iterator[INTERNAL] = { |
| target, |
| kind, |
| index: 0 |
| }; |
| return iterator; |
| } |
| |
| const HeadersIteratorPrototype = Object.setPrototypeOf({ |
| next() { |
| // istanbul ignore if |
| if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { |
| throw new TypeError('Value of `this` is not a HeadersIterator'); |
| } |
| |
| var _INTERNAL = this[INTERNAL]; |
| const target = _INTERNAL.target, |
| kind = _INTERNAL.kind, |
| index = _INTERNAL.index; |
| |
| const values = getHeaders(target, kind); |
| const len = values.length; |
| if (index >= len) { |
| return { |
| value: undefined, |
| done: true |
| }; |
| } |
| |
| this[INTERNAL].index = index + 1; |
| |
| return { |
| value: values[index], |
| done: false |
| }; |
| } |
| }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); |
| |
| Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { |
| value: 'HeadersIterator', |
| writable: false, |
| enumerable: false, |
| configurable: true |
| }); |
| |
| /** |
| * Export the Headers object in a form that Node.js can consume. |
| * |
| * @param Headers headers |
| * @return Object |
| */ |
| function exportNodeCompatibleHeaders(headers) { |
| const obj = Object.assign({ __proto__: null }, headers[MAP]); |
| |
| // http.request() only supports string as Host header. This hack makes |
| // specifying custom Host header possible. |
| const hostHeaderKey = find(headers[MAP], 'Host'); |
| if (hostHeaderKey !== undefined) { |
| obj[hostHeaderKey] = obj[hostHeaderKey][0]; |
| } |
| |
| return obj; |
| } |
| |
| /** |
| * Create a Headers object from an object of headers, ignoring those that do |
| * not conform to HTTP grammar productions. |
| * |
| * @param Object obj Object of headers |
| * @return Headers |
| */ |
| function createHeadersLenient(obj) { |
| const headers = new Headers(); |
| for (const name of Object.keys(obj)) { |
| if (invalidTokenRegex.test(name)) { |
| continue; |
| } |
| if (Array.isArray(obj[name])) { |
| for (const val of obj[name]) { |
| if (invalidHeaderCharRegex.test(val)) { |
| continue; |
| } |
| if (headers[MAP][name] === undefined) { |
| headers[MAP][name] = [val]; |
| } else { |
| headers[MAP][name].push(val); |
| } |
| } |
| } else if (!invalidHeaderCharRegex.test(obj[name])) { |
| headers[MAP][name] = [obj[name]]; |
| } |
| } |
| return headers; |
| } |
| |
| const INTERNALS$1 = Symbol('Response internals'); |
| |
| // fix an issue where "STATUS_CODES" aren't a named export for node <10 |
| const STATUS_CODES = http.STATUS_CODES; |
| |
| /** |
| * Response class |
| * |
| * @param Stream body Readable stream |
| * @param Object opts Response options |
| * @return Void |
| */ |
| class Response { |
| constructor() { |
| let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; |
| let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; |
| |
| Body.call(this, body, opts); |
| |
| const status = opts.status || 200; |
| const headers = new Headers(opts.headers); |
| |
| if (body != null && !headers.has('Content-Type')) { |
| const contentType = extractContentType(body); |
| if (contentType) { |
| headers.append('Content-Type', contentType); |
| } |
| } |
| |
| this[INTERNALS$1] = { |
| url: opts.url, |
| status, |
| statusText: opts.statusText || STATUS_CODES[status], |
| headers, |
| counter: opts.counter |
| }; |
| } |
| |
| get url() { |
| return this[INTERNALS$1].url || ''; |
| } |
| |
| get status() { |
| return this[INTERNALS$1].status; |
| } |
| |
| /** |
| * Convenience property representing if the request ended normally |
| */ |
| get ok() { |
| return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; |
| } |
| |
| get redirected() { |
| return this[INTERNALS$1].counter > 0; |
| } |
| |
| get statusText() { |
| return this[INTERNALS$1].statusText; |
| } |
| |
| get headers() { |
| return this[INTERNALS$1].headers; |
| } |
| |
| /** |
| * Clone this response |
| * |
| * @return Response |
| */ |
| clone() { |
| return new Response(clone(this), { |
| url: this.url, |
| status: this.status, |
| statusText: this.statusText, |
| headers: this.headers, |
| ok: this.ok, |
| redirected: this.redirected |
| }); |
| } |
| } |
| |
| Body.mixIn(Response.prototype); |
| |
| Object.defineProperties(Response.prototype, { |
| url: { enumerable: true }, |
| status: { enumerable: true }, |
| ok: { enumerable: true }, |
| redirected: { enumerable: true }, |
| statusText: { enumerable: true }, |
| headers: { enumerable: true }, |
| clone: { enumerable: true } |
| }); |
| |
| Object.defineProperty(Response.prototype, Symbol.toStringTag, { |
| value: 'Response', |
| writable: false, |
| enumerable: false, |
| configurable: true |
| }); |
| |
| const INTERNALS$2 = Symbol('Request internals'); |
| |
| // fix an issue where "format", "parse" aren't a named export for node <10 |
| const parse_url = Url.parse; |
| const format_url = Url.format; |
| |
| const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; |
| |
| /** |
| * Check if a value is an instance of Request. |
| * |
| * @param Mixed input |
| * @return Boolean |
| */ |
| function isRequest(input) { |
| return typeof input === 'object' && typeof input[INTERNALS$2] === 'object'; |
| } |
| |
| function isAbortSignal(signal) { |
| const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal); |
| return !!(proto && proto.constructor.name === 'AbortSignal'); |
| } |
| |
| /** |
| * Request class |
| * |
| * @param Mixed input Url or Request instance |
| * @param Object init Custom options |
| * @return Void |
| */ |
| class Request { |
| constructor(input) { |
| let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; |
| |
| let parsedURL; |
| |
| // normalize input |
| if (!isRequest(input)) { |
| if (input && input.href) { |
| // in order to support Node.js' Url objects; though WHATWG's URL objects |
| // will fall into this branch also (since their `toString()` will return |
| // `href` property anyway) |
| parsedURL = parse_url(input.href); |
| } else { |
| // coerce input to a string before attempting to parse |
| parsedURL = parse_url(`${input}`); |
| } |
| input = {}; |
| } else { |
| parsedURL = parse_url(input.url); |
| } |
| |
| let method = init.method || input.method || 'GET'; |
| method = method.toUpperCase(); |
| |
| if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) { |
| throw new TypeError('Request with GET/HEAD method cannot have body'); |
| } |
| |
| let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; |
| |
| Body.call(this, inputBody, { |
| timeout: init.timeout || input.timeout || 0, |
| size: init.size || input.size || 0 |
| }); |
| |
| const headers = new Headers(init.headers || input.headers || {}); |
| |
| if (inputBody != null && !headers.has('Content-Type')) { |
| const contentType = extractContentType(inputBody); |
| if (contentType) { |
| headers.append('Content-Type', contentType); |
| } |
| } |
| |
| let signal = isRequest(input) ? input.signal : null; |
| if ('signal' in init) signal = init.signal; |
| |
| if (signal != null && !isAbortSignal(signal)) { |
| throw new TypeError('Expected signal to be an instanceof AbortSignal'); |
| } |
| |
| this[INTERNALS$2] = { |
| method, |
| redirect: init.redirect || input.redirect || 'follow', |
| headers, |
| parsedURL, |
| signal |
| }; |
| |
| // node-fetch-only options |
| this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20; |
| this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true; |
| this.counter = init.counter || input.counter || 0; |
| this.agent = init.agent || input.agent; |
| } |
| |
| get method() { |
| return this[INTERNALS$2].method; |
| } |
| |
| get url() { |
| return format_url(this[INTERNALS$2].parsedURL); |
| } |
| |
| get headers() { |
| return this[INTERNALS$2].headers; |
| } |
| |
| get redirect() { |
| return this[INTERNALS$2].redirect; |
| } |
| |
| get signal() { |
| return this[INTERNALS$2].signal; |
| } |
| |
| /** |
| * Clone this request |
| * |
| * @return Request |
| */ |
| clone() { |
| return new Request(this); |
| } |
| } |
| |
| Body.mixIn(Request.prototype); |
| |
| Object.defineProperty(Request.prototype, Symbol.toStringTag, { |
| value: 'Request', |
| writable: false, |
| enumerable: false, |
| configurable: true |
| }); |
| |
| Object.defineProperties(Request.prototype, { |
| method: { enumerable: true }, |
| url: { enumerable: true }, |
| headers: { enumerable: true }, |
| redirect: { enumerable: true }, |
| clone: { enumerable: true }, |
| signal: { enumerable: true } |
| }); |
| |
| /** |
| * Convert a Request to Node.js http request options. |
| * |
| * @param Request A Request instance |
| * @return Object The options object to be passed to http.request |
| */ |
| function getNodeRequestOptions(request) { |
| const parsedURL = request[INTERNALS$2].parsedURL; |
| const headers = new Headers(request[INTERNALS$2].headers); |
| |
| // fetch step 1.3 |
| if (!headers.has('Accept')) { |
| headers.set('Accept', '*/*'); |
| } |
| |
| // Basic fetch |
| if (!parsedURL.protocol || !parsedURL.hostname) { |
| throw new TypeError('Only absolute URLs are supported'); |
| } |
| |
| if (!/^https?:$/.test(parsedURL.protocol)) { |
| throw new TypeError('Only HTTP(S) protocols are supported'); |
| } |
| |
| if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { |
| throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8'); |
| } |
| |
| // HTTP-network-or-cache fetch steps 2.4-2.7 |
| let contentLengthValue = null; |
| if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { |
| contentLengthValue = '0'; |
| } |
| if (request.body != null) { |
| const totalBytes = getTotalBytes(request); |
| if (typeof totalBytes === 'number') { |
| contentLengthValue = String(totalBytes); |
| } |
| } |
| if (contentLengthValue) { |
| headers.set('Content-Length', contentLengthValue); |
| } |
| |
| // HTTP-network-or-cache fetch step 2.11 |
| if (!headers.has('User-Agent')) { |
| headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)'); |
| } |
| |
| // HTTP-network-or-cache fetch step 2.15 |
| if (request.compress && !headers.has('Accept-Encoding')) { |
| headers.set('Accept-Encoding', 'gzip,deflate'); |
| } |
| |
| let agent = request.agent; |
| if (typeof agent === 'function') { |
| agent = agent(parsedURL); |
| } |
| |
| if (!headers.has('Connection') && !agent) { |
| headers.set('Connection', 'close'); |
| } |
| |
| // HTTP-network fetch step 4.2 |
| // chunked encoding is handled by Node.js |
| |
| return Object.assign({}, parsedURL, { |
| method: request.method, |
| headers: exportNodeCompatibleHeaders(headers), |
| agent |
| }); |
| } |
| |
| /** |
| * abort-error.js |
| * |
| * AbortError interface for cancelled requests |
| */ |
| |
| /** |
| * Create AbortError instance |
| * |
| * @param String message Error message for human |
| * @return AbortError |
| */ |
| function AbortError(message) { |
| Error.call(this, message); |
| |
| this.type = 'aborted'; |
| this.message = message; |
| |
| // hide custom error implementation details from end-users |
| Error.captureStackTrace(this, this.constructor); |
| } |
| |
| AbortError.prototype = Object.create(Error.prototype); |
| AbortError.prototype.constructor = AbortError; |
| AbortError.prototype.name = 'AbortError'; |
| |
| // fix an issue where "PassThrough", "resolve" aren't a named export for node <10 |
| const PassThrough$1 = Stream.PassThrough; |
| const resolve_url = Url.resolve; |
| |
| /** |
| * Fetch function |
| * |
| * @param Mixed url Absolute url or Request instance |
| * @param Object opts Fetch options |
| * @return Promise |
| */ |
| function fetch(url, opts) { |
| |
| // allow custom promise |
| if (!fetch.Promise) { |
| throw new Error('native promise missing, set fetch.Promise to your favorite alternative'); |
| } |
| |
| Body.Promise = fetch.Promise; |
| |
| // wrap http.request into fetch |
| return new fetch.Promise(function (resolve, reject) { |
| // build request object |
| const request = new Request(url, opts); |
| const options = getNodeRequestOptions(request); |
| |
| const send = (options.protocol === 'https:' ? https : http).request; |
| const signal = request.signal; |
| |
| let response = null; |
| |
| const abort = function abort() { |
| let error = new AbortError('The user aborted a request.'); |
| reject(error); |
| if (request.body && request.body instanceof Stream.Readable) { |
| request.body.destroy(error); |
| } |
| if (!response || !response.body) return; |
| response.body.emit('error', error); |
| }; |
| |
| if (signal && signal.aborted) { |
| abort(); |
| return; |
| } |
| |
| const abortAndFinalize = function abortAndFinalize() { |
| abort(); |
| finalize(); |
| }; |
| |
| // send request |
| const req = send(options); |
| let reqTimeout; |
| |
| if (signal) { |
| signal.addEventListener('abort', abortAndFinalize); |
| } |
| |
| function finalize() { |
| req.abort(); |
| if (signal) signal.removeEventListener('abort', abortAndFinalize); |
| clearTimeout(reqTimeout); |
| } |
| |
| if (request.timeout) { |
| req.once('socket', function (socket) { |
| reqTimeout = setTimeout(function () { |
| reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout')); |
| finalize(); |
| }, request.timeout); |
| }); |
| } |
| |
| req.on('error', function (err) { |
| reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err)); |
| finalize(); |
| }); |
| |
| req.on('response', function (res) { |
| clearTimeout(reqTimeout); |
| |
| const headers = createHeadersLenient(res.headers); |
| |
| // HTTP fetch step 5 |
| if (fetch.isRedirect(res.statusCode)) { |
| // HTTP fetch step 5.2 |
| const location = headers.get('Location'); |
| |
| // HTTP fetch step 5.3 |
| const locationURL = location === null ? null : resolve_url(request.url, location); |
| |
| // HTTP fetch step 5.5 |
| switch (request.redirect) { |
| case 'error': |
| reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect')); |
| finalize(); |
| return; |
| case 'manual': |
| // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. |
| if (locationURL !== null) { |
| // handle corrupted header |
| try { |
| headers.set('Location', locationURL); |
| } catch (err) { |
| // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request |
| reject(err); |
| } |
| } |
| break; |
| case 'follow': |
| // HTTP-redirect fetch step 2 |
| if (locationURL === null) { |
| break; |
| } |
| |
| // HTTP-redirect fetch step 5 |
| if (request.counter >= request.follow) { |
| reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); |
| finalize(); |
| return; |
| } |
| |
| // HTTP-redirect fetch step 6 (counter increment) |
| // Create a new Request object. |
| const requestOpts = { |
| headers: new Headers(request.headers), |
| follow: request.follow, |
| counter: request.counter + 1, |
| agent: request.agent, |
| compress: request.compress, |
| method: request.method, |
| body: request.body, |
| signal: request.signal, |
| timeout: request.timeout, |
| size: request.size |
| }; |
| |
| // HTTP-redirect fetch step 9 |
| if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { |
| reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect')); |
| finalize(); |
| return; |
| } |
| |
| // HTTP-redirect fetch step 11 |
| if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') { |
| requestOpts.method = 'GET'; |
| requestOpts.body = undefined; |
| requestOpts.headers.delete('content-length'); |
| } |
| |
| // HTTP-redirect fetch step 15 |
| resolve(fetch(new Request(locationURL, requestOpts))); |
| finalize(); |
| return; |
| } |
| } |
| |
| // prepare response |
| res.once('end', function () { |
| if (signal) signal.removeEventListener('abort', abortAndFinalize); |
| }); |
| let body = res.pipe(new PassThrough$1()); |
| |
| const response_options = { |
| url: request.url, |
| status: res.statusCode, |
| statusText: res.statusMessage, |
| headers: headers, |
| size: request.size, |
| timeout: request.timeout, |
| counter: request.counter |
| }; |
| |
| // HTTP-network fetch step 12.1.1.3 |
| const codings = headers.get('Content-Encoding'); |
| |
| // HTTP-network fetch step 12.1.1.4: handle content codings |
| |
| // in following scenarios we ignore compression support |
| // 1. compression support is disabled |
| // 2. HEAD request |
| // 3. no Content-Encoding header |
| // 4. no content response (204) |
| // 5. content not modified response (304) |
| if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) { |
| response = new Response(body, response_options); |
| resolve(response); |
| return; |
| } |
| |
| // For Node v6+ |
| // Be less strict when decoding compressed responses, since sometimes |
| // servers send slightly invalid responses that are still accepted |
| // by common browsers. |
| // Always using Z_SYNC_FLUSH is what cURL does. |
| const zlibOptions = { |
| flush: zlib.Z_SYNC_FLUSH, |
| finishFlush: zlib.Z_SYNC_FLUSH |
| }; |
| |
| // for gzip |
| if (codings == 'gzip' || codings == 'x-gzip') { |
| body = body.pipe(zlib.createGunzip(zlibOptions)); |
| response = new Response(body, response_options); |
| resolve(response); |
| return; |
| } |
| |
| // for deflate |
| if (codings == 'deflate' || codings == 'x-deflate') { |
| // handle the infamous raw deflate response from old servers |
| // a hack for old IIS and Apache servers |
| const raw = res.pipe(new PassThrough$1()); |
| raw.once('data', function (chunk) { |
| // see http://stackoverflow.com/questions/37519828 |
| if ((chunk[0] & 0x0F) === 0x08) { |
| body = body.pipe(zlib.createInflate()); |
| } else { |
| body = body.pipe(zlib.createInflateRaw()); |
| } |
| response = new Response(body, response_options); |
| resolve(response); |
| }); |
| return; |
| } |
| |
| // for br |
| if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') { |
| body = body.pipe(zlib.createBrotliDecompress()); |
| response = new Response(body, response_options); |
| resolve(response); |
| return; |
| } |
| |
| // otherwise, use response as-is |
| response = new Response(body, response_options); |
| resolve(response); |
| }); |
| |
| writeToStream(req, request); |
| }); |
| } |
| /** |
| * Redirect code matching |
| * |
| * @param Number code Status code |
| * @return Boolean |
| */ |
| fetch.isRedirect = function (code) { |
| return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; |
| }; |
| |
| // expose Promise |
| fetch.Promise = global.Promise; |
| |
| module.exports = exports = fetch; |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| exports.default = exports; |
| exports.Headers = Headers; |
| exports.Request = Request; |
| exports.Response = Response; |
| exports.FetchError = FetchError; |
| |
| |
| /***/ }), |
| |
| /***/ 7952: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| // TODO: Use the `URL` global when targeting Node.js 10 |
| const URLParser = typeof URL === 'undefined' ? __nccwpck_require__(8835).URL : URL; |
| |
| // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs |
| const DATA_URL_DEFAULT_MIME_TYPE = 'text/plain'; |
| const DATA_URL_DEFAULT_CHARSET = 'us-ascii'; |
| |
| const testParameter = (name, filters) => { |
| return filters.some(filter => filter instanceof RegExp ? filter.test(name) : filter === name); |
| }; |
| |
| const normalizeDataURL = (urlString, {stripHash}) => { |
| const parts = urlString.match(/^data:(.*?),(.*?)(?:#(.*))?$/); |
| |
| if (!parts) { |
| throw new Error(`Invalid URL: ${urlString}`); |
| } |
| |
| const mediaType = parts[1].split(';'); |
| const body = parts[2]; |
| const hash = stripHash ? '' : parts[3]; |
| |
| let base64 = false; |
| |
| if (mediaType[mediaType.length - 1] === 'base64') { |
| mediaType.pop(); |
| base64 = true; |
| } |
| |
| // Lowercase MIME type |
| const mimeType = (mediaType.shift() || '').toLowerCase(); |
| const attributes = mediaType |
| .map(attribute => { |
| let [key, value = ''] = attribute.split('=').map(string => string.trim()); |
| |
| // Lowercase `charset` |
| if (key === 'charset') { |
| value = value.toLowerCase(); |
| |
| if (value === DATA_URL_DEFAULT_CHARSET) { |
| return ''; |
| } |
| } |
| |
| return `${key}${value ? `=${value}` : ''}`; |
| }) |
| .filter(Boolean); |
| |
| const normalizedMediaType = [ |
| ...attributes |
| ]; |
| |
| if (base64) { |
| normalizedMediaType.push('base64'); |
| } |
| |
| if (normalizedMediaType.length !== 0 || (mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE)) { |
| normalizedMediaType.unshift(mimeType); |
| } |
| |
| return `data:${normalizedMediaType.join(';')},${base64 ? body.trim() : body}${hash ? `#${hash}` : ''}`; |
| }; |
| |
| const normalizeUrl = (urlString, options) => { |
| options = { |
| defaultProtocol: 'http:', |
| normalizeProtocol: true, |
| forceHttp: false, |
| forceHttps: false, |
| stripAuthentication: true, |
| stripHash: false, |
| stripWWW: true, |
| removeQueryParameters: [/^utm_\w+/i], |
| removeTrailingSlash: true, |
| removeDirectoryIndex: false, |
| sortQueryParameters: true, |
| ...options |
| }; |
| |
| // TODO: Remove this at some point in the future |
| if (Reflect.has(options, 'normalizeHttps')) { |
| throw new Error('options.normalizeHttps is renamed to options.forceHttp'); |
| } |
| |
| if (Reflect.has(options, 'normalizeHttp')) { |
| throw new Error('options.normalizeHttp is renamed to options.forceHttps'); |
| } |
| |
| if (Reflect.has(options, 'stripFragment')) { |
| throw new Error('options.stripFragment is renamed to options.stripHash'); |
| } |
| |
| urlString = urlString.trim(); |
| |
| // Data URL |
| if (/^data:/i.test(urlString)) { |
| return normalizeDataURL(urlString, options); |
| } |
| |
| const hasRelativeProtocol = urlString.startsWith('//'); |
| const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString); |
| |
| // Prepend protocol |
| if (!isRelativeUrl) { |
| urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol); |
| } |
| |
| const urlObj = new URLParser(urlString); |
| |
| if (options.forceHttp && options.forceHttps) { |
| throw new Error('The `forceHttp` and `forceHttps` options cannot be used together'); |
| } |
| |
| if (options.forceHttp && urlObj.protocol === 'https:') { |
| urlObj.protocol = 'http:'; |
| } |
| |
| if (options.forceHttps && urlObj.protocol === 'http:') { |
| urlObj.protocol = 'https:'; |
| } |
| |
| // Remove auth |
| if (options.stripAuthentication) { |
| urlObj.username = ''; |
| urlObj.password = ''; |
| } |
| |
| // Remove hash |
| if (options.stripHash) { |
| urlObj.hash = ''; |
| } |
| |
| // Remove duplicate slashes if not preceded by a protocol |
| if (urlObj.pathname) { |
| // TODO: Use the following instead when targeting Node.js 10 |
| // `urlObj.pathname = urlObj.pathname.replace(/(?<!https?:)\/{2,}/g, '/');` |
| urlObj.pathname = urlObj.pathname.replace(/((?!:).|^)\/{2,}/g, (_, p1) => { |
| if (/^(?!\/)/g.test(p1)) { |
| return `${p1}/`; |
| } |
| |
| return '/'; |
| }); |
| } |
| |
| // Decode URI octets |
| if (urlObj.pathname) { |
| urlObj.pathname = decodeURI(urlObj.pathname); |
| } |
| |
| // Remove directory index |
| if (options.removeDirectoryIndex === true) { |
| options.removeDirectoryIndex = [/^index\.[a-z]+$/]; |
| } |
| |
| if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) { |
| let pathComponents = urlObj.pathname.split('/'); |
| const lastComponent = pathComponents[pathComponents.length - 1]; |
| |
| if (testParameter(lastComponent, options.removeDirectoryIndex)) { |
| pathComponents = pathComponents.slice(0, pathComponents.length - 1); |
| urlObj.pathname = pathComponents.slice(1).join('/') + '/'; |
| } |
| } |
| |
| if (urlObj.hostname) { |
| // Remove trailing dot |
| urlObj.hostname = urlObj.hostname.replace(/\.$/, ''); |
| |
| // Remove `www.` |
| if (options.stripWWW && /^www\.([a-z\-\d]{2,63})\.([a-z.]{2,5})$/.test(urlObj.hostname)) { |
| // Each label should be max 63 at length (min: 2). |
| // The extension should be max 5 at length (min: 2). |
| // Source: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names |
| urlObj.hostname = urlObj.hostname.replace(/^www\./, ''); |
| } |
| } |
| |
| // Remove query unwanted parameters |
| if (Array.isArray(options.removeQueryParameters)) { |
| for (const key of [...urlObj.searchParams.keys()]) { |
| if (testParameter(key, options.removeQueryParameters)) { |
| urlObj.searchParams.delete(key); |
| } |
| } |
| } |
| |
| // Sort query parameters |
| if (options.sortQueryParameters) { |
| urlObj.searchParams.sort(); |
| } |
| |
| if (options.removeTrailingSlash) { |
| urlObj.pathname = urlObj.pathname.replace(/\/$/, ''); |
| } |
| |
| // Take advantage of many of the Node `url` normalizations |
| urlString = urlObj.toString(); |
| |
| // Remove ending `/` |
| if ((options.removeTrailingSlash || urlObj.pathname === '/') && urlObj.hash === '') { |
| urlString = urlString.replace(/\/$/, ''); |
| } |
| |
| // Restore relative protocol, if applicable |
| if (hasRelativeProtocol && !options.normalizeProtocol) { |
| urlString = urlString.replace(/^http:\/\//, '//'); |
| } |
| |
| // Remove http/https |
| if (options.stripProtocol) { |
| urlString = urlString.replace(/^(?:https?:)?\/\//, ''); |
| } |
| |
| return urlString; |
| }; |
| |
| module.exports = normalizeUrl; |
| // TODO: Remove this for the next major release |
| module.exports.default = normalizeUrl; |
| |
| |
| /***/ }), |
| |
| /***/ 1223: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var wrappy = __nccwpck_require__(2940) |
| module.exports = wrappy(once) |
| module.exports.strict = wrappy(onceStrict) |
| |
| once.proto = once(function () { |
| Object.defineProperty(Function.prototype, 'once', { |
| value: function () { |
| return once(this) |
| }, |
| configurable: true |
| }) |
| |
| Object.defineProperty(Function.prototype, 'onceStrict', { |
| value: function () { |
| return onceStrict(this) |
| }, |
| configurable: true |
| }) |
| }) |
| |
| function once (fn) { |
| var f = function () { |
| if (f.called) return f.value |
| f.called = true |
| return f.value = fn.apply(this, arguments) |
| } |
| f.called = false |
| return f |
| } |
| |
| function onceStrict (fn) { |
| var f = function () { |
| if (f.called) |
| throw new Error(f.onceError) |
| f.called = true |
| return f.value = fn.apply(this, arguments) |
| } |
| var name = fn.name || 'Function wrapped with `once`' |
| f.onceError = name + " shouldn't be called more than once" |
| f.called = false |
| return f |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 9072: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| class CancelError extends Error { |
| constructor(reason) { |
| super(reason || 'Promise was canceled'); |
| this.name = 'CancelError'; |
| } |
| |
| get isCanceled() { |
| return true; |
| } |
| } |
| |
| class PCancelable { |
| static fn(userFn) { |
| return (...arguments_) => { |
| return new PCancelable((resolve, reject, onCancel) => { |
| arguments_.push(onCancel); |
| // eslint-disable-next-line promise/prefer-await-to-then |
| userFn(...arguments_).then(resolve, reject); |
| }); |
| }; |
| } |
| |
| constructor(executor) { |
| this._cancelHandlers = []; |
| this._isPending = true; |
| this._isCanceled = false; |
| this._rejectOnCancel = true; |
| |
| this._promise = new Promise((resolve, reject) => { |
| this._reject = reject; |
| |
| const onResolve = value => { |
| this._isPending = false; |
| resolve(value); |
| }; |
| |
| const onReject = error => { |
| this._isPending = false; |
| reject(error); |
| }; |
| |
| const onCancel = handler => { |
| if (!this._isPending) { |
| throw new Error('The `onCancel` handler was attached after the promise settled.'); |
| } |
| |
| this._cancelHandlers.push(handler); |
| }; |
| |
| Object.defineProperties(onCancel, { |
| shouldReject: { |
| get: () => this._rejectOnCancel, |
| set: boolean => { |
| this._rejectOnCancel = boolean; |
| } |
| } |
| }); |
| |
| return executor(onResolve, onReject, onCancel); |
| }); |
| } |
| |
| then(onFulfilled, onRejected) { |
| // eslint-disable-next-line promise/prefer-await-to-then |
| return this._promise.then(onFulfilled, onRejected); |
| } |
| |
| catch(onRejected) { |
| return this._promise.catch(onRejected); |
| } |
| |
| finally(onFinally) { |
| return this._promise.finally(onFinally); |
| } |
| |
| cancel(reason) { |
| if (!this._isPending || this._isCanceled) { |
| return; |
| } |
| |
| if (this._cancelHandlers.length > 0) { |
| try { |
| for (const handler of this._cancelHandlers) { |
| handler(); |
| } |
| } catch (error) { |
| this._reject(error); |
| } |
| } |
| |
| this._isCanceled = true; |
| if (this._rejectOnCancel) { |
| this._reject(new CancelError(reason)); |
| } |
| } |
| |
| get isCanceled() { |
| return this._isCanceled; |
| } |
| } |
| |
| Object.setPrototypeOf(PCancelable.prototype, Promise.prototype); |
| |
| module.exports = PCancelable; |
| module.exports.CancelError = CancelError; |
| |
| |
| /***/ }), |
| |
| /***/ 8569: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| module.exports = __nccwpck_require__(3322); |
| |
| |
| /***/ }), |
| |
| /***/ 6099: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const path = __nccwpck_require__(5622); |
| const WIN_SLASH = '\\\\/'; |
| const WIN_NO_SLASH = `[^${WIN_SLASH}]`; |
| |
| /** |
| * Posix glob regex |
| */ |
| |
| const DOT_LITERAL = '\\.'; |
| const PLUS_LITERAL = '\\+'; |
| const QMARK_LITERAL = '\\?'; |
| const SLASH_LITERAL = '\\/'; |
| const ONE_CHAR = '(?=.)'; |
| const QMARK = '[^/]'; |
| const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; |
| const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; |
| const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; |
| const NO_DOT = `(?!${DOT_LITERAL})`; |
| const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; |
| const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; |
| const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; |
| const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; |
| const STAR = `${QMARK}*?`; |
| |
| const POSIX_CHARS = { |
| DOT_LITERAL, |
| PLUS_LITERAL, |
| QMARK_LITERAL, |
| SLASH_LITERAL, |
| ONE_CHAR, |
| QMARK, |
| END_ANCHOR, |
| DOTS_SLASH, |
| NO_DOT, |
| NO_DOTS, |
| NO_DOT_SLASH, |
| NO_DOTS_SLASH, |
| QMARK_NO_DOT, |
| STAR, |
| START_ANCHOR |
| }; |
| |
| /** |
| * Windows glob regex |
| */ |
| |
| const WINDOWS_CHARS = { |
| ...POSIX_CHARS, |
| |
| SLASH_LITERAL: `[${WIN_SLASH}]`, |
| QMARK: WIN_NO_SLASH, |
| STAR: `${WIN_NO_SLASH}*?`, |
| DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, |
| NO_DOT: `(?!${DOT_LITERAL})`, |
| NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, |
| NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, |
| NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, |
| QMARK_NO_DOT: `[^.${WIN_SLASH}]`, |
| START_ANCHOR: `(?:^|[${WIN_SLASH}])`, |
| END_ANCHOR: `(?:[${WIN_SLASH}]|$)` |
| }; |
| |
| /** |
| * POSIX Bracket Regex |
| */ |
| |
| const POSIX_REGEX_SOURCE = { |
| alnum: 'a-zA-Z0-9', |
| alpha: 'a-zA-Z', |
| ascii: '\\x00-\\x7F', |
| blank: ' \\t', |
| cntrl: '\\x00-\\x1F\\x7F', |
| digit: '0-9', |
| graph: '\\x21-\\x7E', |
| lower: 'a-z', |
| print: '\\x20-\\x7E ', |
| punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', |
| space: ' \\t\\r\\n\\v\\f', |
| upper: 'A-Z', |
| word: 'A-Za-z0-9_', |
| xdigit: 'A-Fa-f0-9' |
| }; |
| |
| module.exports = { |
| MAX_LENGTH: 1024 * 64, |
| POSIX_REGEX_SOURCE, |
| |
| // regular expressions |
| REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, |
| REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, |
| REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, |
| REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, |
| REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, |
| REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, |
| |
| // Replace globs with equivalent patterns to reduce parsing time. |
| REPLACEMENTS: { |
| '***': '*', |
| '**/**': '**', |
| '**/**/**': '**' |
| }, |
| |
| // Digits |
| CHAR_0: 48, /* 0 */ |
| CHAR_9: 57, /* 9 */ |
| |
| // Alphabet chars. |
| CHAR_UPPERCASE_A: 65, /* A */ |
| CHAR_LOWERCASE_A: 97, /* a */ |
| CHAR_UPPERCASE_Z: 90, /* Z */ |
| CHAR_LOWERCASE_Z: 122, /* z */ |
| |
| CHAR_LEFT_PARENTHESES: 40, /* ( */ |
| CHAR_RIGHT_PARENTHESES: 41, /* ) */ |
| |
| CHAR_ASTERISK: 42, /* * */ |
| |
| // Non-alphabetic chars. |
| CHAR_AMPERSAND: 38, /* & */ |
| CHAR_AT: 64, /* @ */ |
| CHAR_BACKWARD_SLASH: 92, /* \ */ |
| CHAR_CARRIAGE_RETURN: 13, /* \r */ |
| CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */ |
| CHAR_COLON: 58, /* : */ |
| CHAR_COMMA: 44, /* , */ |
| CHAR_DOT: 46, /* . */ |
| CHAR_DOUBLE_QUOTE: 34, /* " */ |
| CHAR_EQUAL: 61, /* = */ |
| CHAR_EXCLAMATION_MARK: 33, /* ! */ |
| CHAR_FORM_FEED: 12, /* \f */ |
| CHAR_FORWARD_SLASH: 47, /* / */ |
| CHAR_GRAVE_ACCENT: 96, /* ` */ |
| CHAR_HASH: 35, /* # */ |
| CHAR_HYPHEN_MINUS: 45, /* - */ |
| CHAR_LEFT_ANGLE_BRACKET: 60, /* < */ |
| CHAR_LEFT_CURLY_BRACE: 123, /* { */ |
| CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */ |
| CHAR_LINE_FEED: 10, /* \n */ |
| CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */ |
| CHAR_PERCENT: 37, /* % */ |
| CHAR_PLUS: 43, /* + */ |
| CHAR_QUESTION_MARK: 63, /* ? */ |
| CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */ |
| CHAR_RIGHT_CURLY_BRACE: 125, /* } */ |
| CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */ |
| CHAR_SEMICOLON: 59, /* ; */ |
| CHAR_SINGLE_QUOTE: 39, /* ' */ |
| CHAR_SPACE: 32, /* */ |
| CHAR_TAB: 9, /* \t */ |
| CHAR_UNDERSCORE: 95, /* _ */ |
| CHAR_VERTICAL_LINE: 124, /* | */ |
| CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */ |
| |
| SEP: path.sep, |
| |
| /** |
| * Create EXTGLOB_CHARS |
| */ |
| |
| extglobChars(chars) { |
| return { |
| '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` }, |
| '?': { type: 'qmark', open: '(?:', close: ')?' }, |
| '+': { type: 'plus', open: '(?:', close: ')+' }, |
| '*': { type: 'star', open: '(?:', close: ')*' }, |
| '@': { type: 'at', open: '(?:', close: ')' } |
| }; |
| }, |
| |
| /** |
| * Create GLOB_CHARS |
| */ |
| |
| globChars(win32) { |
| return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; |
| } |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 2139: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const constants = __nccwpck_require__(6099); |
| const utils = __nccwpck_require__(479); |
| |
| /** |
| * Constants |
| */ |
| |
| const { |
| MAX_LENGTH, |
| POSIX_REGEX_SOURCE, |
| REGEX_NON_SPECIAL_CHARS, |
| REGEX_SPECIAL_CHARS_BACKREF, |
| REPLACEMENTS |
| } = constants; |
| |
| /** |
| * Helpers |
| */ |
| |
| const expandRange = (args, options) => { |
| if (typeof options.expandRange === 'function') { |
| return options.expandRange(...args, options); |
| } |
| |
| args.sort(); |
| const value = `[${args.join('-')}]`; |
| |
| try { |
| /* eslint-disable-next-line no-new */ |
| new RegExp(value); |
| } catch (ex) { |
| return args.map(v => utils.escapeRegex(v)).join('..'); |
| } |
| |
| return value; |
| }; |
| |
| /** |
| * Create the message for a syntax error |
| */ |
| |
| const syntaxError = (type, char) => { |
| return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; |
| }; |
| |
| /** |
| * Parse the given input string. |
| * @param {String} input |
| * @param {Object} options |
| * @return {Object} |
| */ |
| |
| const parse = (input, options) => { |
| if (typeof input !== 'string') { |
| throw new TypeError('Expected a string'); |
| } |
| |
| input = REPLACEMENTS[input] || input; |
| |
| const opts = { ...options }; |
| const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; |
| |
| let len = input.length; |
| if (len > max) { |
| throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); |
| } |
| |
| const bos = { type: 'bos', value: '', output: opts.prepend || '' }; |
| const tokens = [bos]; |
| |
| const capture = opts.capture ? '' : '?:'; |
| const win32 = utils.isWindows(options); |
| |
| // create constants based on platform, for windows or posix |
| const PLATFORM_CHARS = constants.globChars(win32); |
| const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS); |
| |
| const { |
| DOT_LITERAL, |
| PLUS_LITERAL, |
| SLASH_LITERAL, |
| ONE_CHAR, |
| DOTS_SLASH, |
| NO_DOT, |
| NO_DOT_SLASH, |
| NO_DOTS_SLASH, |
| QMARK, |
| QMARK_NO_DOT, |
| STAR, |
| START_ANCHOR |
| } = PLATFORM_CHARS; |
| |
| const globstar = (opts) => { |
| return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; |
| }; |
| |
| const nodot = opts.dot ? '' : NO_DOT; |
| const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; |
| let star = opts.bash === true ? globstar(opts) : STAR; |
| |
| if (opts.capture) { |
| star = `(${star})`; |
| } |
| |
| // minimatch options support |
| if (typeof opts.noext === 'boolean') { |
| opts.noextglob = opts.noext; |
| } |
| |
| const state = { |
| input, |
| index: -1, |
| start: 0, |
| dot: opts.dot === true, |
| consumed: '', |
| output: '', |
| prefix: '', |
| backtrack: false, |
| negated: false, |
| brackets: 0, |
| braces: 0, |
| parens: 0, |
| quotes: 0, |
| globstar: false, |
| tokens |
| }; |
| |
| input = utils.removePrefix(input, state); |
| len = input.length; |
| |
| const extglobs = []; |
| const braces = []; |
| const stack = []; |
| let prev = bos; |
| let value; |
| |
| /** |
| * Tokenizing helpers |
| */ |
| |
| const eos = () => state.index === len - 1; |
| const peek = state.peek = (n = 1) => input[state.index + n]; |
| const advance = state.advance = () => input[++state.index]; |
| const remaining = () => input.slice(state.index + 1); |
| const consume = (value = '', num = 0) => { |
| state.consumed += value; |
| state.index += num; |
| }; |
| const append = token => { |
| state.output += token.output != null ? token.output : token.value; |
| consume(token.value); |
| }; |
| |
| const negate = () => { |
| let count = 1; |
| |
| while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) { |
| advance(); |
| state.start++; |
| count++; |
| } |
| |
| if (count % 2 === 0) { |
| return false; |
| } |
| |
| state.negated = true; |
| state.start++; |
| return true; |
| }; |
| |
| const increment = type => { |
| state[type]++; |
| stack.push(type); |
| }; |
| |
| const decrement = type => { |
| state[type]--; |
| stack.pop(); |
| }; |
| |
| /** |
| * Push tokens onto the tokens array. This helper speeds up |
| * tokenizing by 1) helping us avoid backtracking as much as possible, |
| * and 2) helping us avoid creating extra tokens when consecutive |
| * characters are plain text. This improves performance and simplifies |
| * lookbehinds. |
| */ |
| |
| const push = tok => { |
| if (prev.type === 'globstar') { |
| const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); |
| const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren')); |
| |
| if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { |
| state.output = state.output.slice(0, -prev.output.length); |
| prev.type = 'star'; |
| prev.value = '*'; |
| prev.output = star; |
| state.output += prev.output; |
| } |
| } |
| |
| if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) { |
| extglobs[extglobs.length - 1].inner += tok.value; |
| } |
| |
| if (tok.value || tok.output) append(tok); |
| if (prev && prev.type === 'text' && tok.type === 'text') { |
| prev.value += tok.value; |
| prev.output = (prev.output || '') + tok.value; |
| return; |
| } |
| |
| tok.prev = prev; |
| tokens.push(tok); |
| prev = tok; |
| }; |
| |
| const extglobOpen = (type, value) => { |
| const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' }; |
| |
| token.prev = prev; |
| token.parens = state.parens; |
| token.output = state.output; |
| const output = (opts.capture ? '(' : '') + token.open; |
| |
| increment('parens'); |
| push({ type, value, output: state.output ? '' : ONE_CHAR }); |
| push({ type: 'paren', extglob: true, value: advance(), output }); |
| extglobs.push(token); |
| }; |
| |
| const extglobClose = token => { |
| let output = token.close + (opts.capture ? ')' : ''); |
| |
| if (token.type === 'negate') { |
| let extglobStar = star; |
| |
| if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { |
| extglobStar = globstar(opts); |
| } |
| |
| if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) { |
| output = token.close = `)$))${extglobStar}`; |
| } |
| |
| if (token.prev.type === 'bos' && eos()) { |
| state.negatedExtglob = true; |
| } |
| } |
| |
| push({ type: 'paren', extglob: true, value, output }); |
| decrement('parens'); |
| }; |
| |
| /** |
| * Fast paths |
| */ |
| |
| if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) { |
| let backslashes = false; |
| |
| let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { |
| if (first === '\\') { |
| backslashes = true; |
| return m; |
| } |
| |
| if (first === '?') { |
| if (esc) { |
| return esc + first + (rest ? QMARK.repeat(rest.length) : ''); |
| } |
| if (index === 0) { |
| return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); |
| } |
| return QMARK.repeat(chars.length); |
| } |
| |
| if (first === '.') { |
| return DOT_LITERAL.repeat(chars.length); |
| } |
| |
| if (first === '*') { |
| if (esc) { |
| return esc + first + (rest ? star : ''); |
| } |
| return star; |
| } |
| return esc ? m : `\\${m}`; |
| }); |
| |
| if (backslashes === true) { |
| if (opts.unescape === true) { |
| output = output.replace(/\\/g, ''); |
| } else { |
| output = output.replace(/\\+/g, m => { |
| return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : ''); |
| }); |
| } |
| } |
| |
| if (output === input && opts.contains === true) { |
| state.output = input; |
| return state; |
| } |
| |
| state.output = utils.wrapOutput(output, state, options); |
| return state; |
| } |
| |
| /** |
| * Tokenize input until we reach end-of-string |
| */ |
| |
| while (!eos()) { |
| value = advance(); |
| |
| if (value === '\u0000') { |
| continue; |
| } |
| |
| /** |
| * Escaped characters |
| */ |
| |
| if (value === '\\') { |
| const next = peek(); |
| |
| if (next === '/' && opts.bash !== true) { |
| continue; |
| } |
| |
| if (next === '.' || next === ';') { |
| continue; |
| } |
| |
| if (!next) { |
| value += '\\'; |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| // collapse slashes to reduce potential for exploits |
| const match = /^\\+/.exec(remaining()); |
| let slashes = 0; |
| |
| if (match && match[0].length > 2) { |
| slashes = match[0].length; |
| state.index += slashes; |
| if (slashes % 2 !== 0) { |
| value += '\\'; |
| } |
| } |
| |
| if (opts.unescape === true) { |
| value = advance() || ''; |
| } else { |
| value += advance() || ''; |
| } |
| |
| if (state.brackets === 0) { |
| push({ type: 'text', value }); |
| continue; |
| } |
| } |
| |
| /** |
| * If we're inside a regex character class, continue |
| * until we reach the closing bracket. |
| */ |
| |
| if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { |
| if (opts.posix !== false && value === ':') { |
| const inner = prev.value.slice(1); |
| if (inner.includes('[')) { |
| prev.posix = true; |
| |
| if (inner.includes(':')) { |
| const idx = prev.value.lastIndexOf('['); |
| const pre = prev.value.slice(0, idx); |
| const rest = prev.value.slice(idx + 2); |
| const posix = POSIX_REGEX_SOURCE[rest]; |
| if (posix) { |
| prev.value = pre + posix; |
| state.backtrack = true; |
| advance(); |
| |
| if (!bos.output && tokens.indexOf(prev) === 1) { |
| bos.output = ONE_CHAR; |
| } |
| continue; |
| } |
| } |
| } |
| } |
| |
| if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) { |
| value = `\\${value}`; |
| } |
| |
| if (value === ']' && (prev.value === '[' || prev.value === '[^')) { |
| value = `\\${value}`; |
| } |
| |
| if (opts.posix === true && value === '!' && prev.value === '[') { |
| value = '^'; |
| } |
| |
| prev.value += value; |
| append({ value }); |
| continue; |
| } |
| |
| /** |
| * If we're inside a quoted string, continue |
| * until we reach the closing double quote. |
| */ |
| |
| if (state.quotes === 1 && value !== '"') { |
| value = utils.escapeRegex(value); |
| prev.value += value; |
| append({ value }); |
| continue; |
| } |
| |
| /** |
| * Double quotes |
| */ |
| |
| if (value === '"') { |
| state.quotes = state.quotes === 1 ? 0 : 1; |
| if (opts.keepQuotes === true) { |
| push({ type: 'text', value }); |
| } |
| continue; |
| } |
| |
| /** |
| * Parentheses |
| */ |
| |
| if (value === '(') { |
| increment('parens'); |
| push({ type: 'paren', value }); |
| continue; |
| } |
| |
| if (value === ')') { |
| if (state.parens === 0 && opts.strictBrackets === true) { |
| throw new SyntaxError(syntaxError('opening', '(')); |
| } |
| |
| const extglob = extglobs[extglobs.length - 1]; |
| if (extglob && state.parens === extglob.parens + 1) { |
| extglobClose(extglobs.pop()); |
| continue; |
| } |
| |
| push({ type: 'paren', value, output: state.parens ? ')' : '\\)' }); |
| decrement('parens'); |
| continue; |
| } |
| |
| /** |
| * Square brackets |
| */ |
| |
| if (value === '[') { |
| if (opts.nobracket === true || !remaining().includes(']')) { |
| if (opts.nobracket !== true && opts.strictBrackets === true) { |
| throw new SyntaxError(syntaxError('closing', ']')); |
| } |
| |
| value = `\\${value}`; |
| } else { |
| increment('brackets'); |
| } |
| |
| push({ type: 'bracket', value }); |
| continue; |
| } |
| |
| if (value === ']') { |
| if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) { |
| push({ type: 'text', value, output: `\\${value}` }); |
| continue; |
| } |
| |
| if (state.brackets === 0) { |
| if (opts.strictBrackets === true) { |
| throw new SyntaxError(syntaxError('opening', '[')); |
| } |
| |
| push({ type: 'text', value, output: `\\${value}` }); |
| continue; |
| } |
| |
| decrement('brackets'); |
| |
| const prevValue = prev.value.slice(1); |
| if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { |
| value = `/${value}`; |
| } |
| |
| prev.value += value; |
| append({ value }); |
| |
| // when literal brackets are explicitly disabled |
| // assume we should match with a regex character class |
| if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) { |
| continue; |
| } |
| |
| const escaped = utils.escapeRegex(prev.value); |
| state.output = state.output.slice(0, -prev.value.length); |
| |
| // when literal brackets are explicitly enabled |
| // assume we should escape the brackets to match literal characters |
| if (opts.literalBrackets === true) { |
| state.output += escaped; |
| prev.value = escaped; |
| continue; |
| } |
| |
| // when the user specifies nothing, try to match both |
| prev.value = `(${capture}${escaped}|${prev.value})`; |
| state.output += prev.value; |
| continue; |
| } |
| |
| /** |
| * Braces |
| */ |
| |
| if (value === '{' && opts.nobrace !== true) { |
| increment('braces'); |
| |
| const open = { |
| type: 'brace', |
| value, |
| output: '(', |
| outputIndex: state.output.length, |
| tokensIndex: state.tokens.length |
| }; |
| |
| braces.push(open); |
| push(open); |
| continue; |
| } |
| |
| if (value === '}') { |
| const brace = braces[braces.length - 1]; |
| |
| if (opts.nobrace === true || !brace) { |
| push({ type: 'text', value, output: value }); |
| continue; |
| } |
| |
| let output = ')'; |
| |
| if (brace.dots === true) { |
| const arr = tokens.slice(); |
| const range = []; |
| |
| for (let i = arr.length - 1; i >= 0; i--) { |
| tokens.pop(); |
| if (arr[i].type === 'brace') { |
| break; |
| } |
| if (arr[i].type !== 'dots') { |
| range.unshift(arr[i].value); |
| } |
| } |
| |
| output = expandRange(range, opts); |
| state.backtrack = true; |
| } |
| |
| if (brace.comma !== true && brace.dots !== true) { |
| const out = state.output.slice(0, brace.outputIndex); |
| const toks = state.tokens.slice(brace.tokensIndex); |
| brace.value = brace.output = '\\{'; |
| value = output = '\\}'; |
| state.output = out; |
| for (const t of toks) { |
| state.output += (t.output || t.value); |
| } |
| } |
| |
| push({ type: 'brace', value, output }); |
| decrement('braces'); |
| braces.pop(); |
| continue; |
| } |
| |
| /** |
| * Pipes |
| */ |
| |
| if (value === '|') { |
| if (extglobs.length > 0) { |
| extglobs[extglobs.length - 1].conditions++; |
| } |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| /** |
| * Commas |
| */ |
| |
| if (value === ',') { |
| let output = value; |
| |
| const brace = braces[braces.length - 1]; |
| if (brace && stack[stack.length - 1] === 'braces') { |
| brace.comma = true; |
| output = '|'; |
| } |
| |
| push({ type: 'comma', value, output }); |
| continue; |
| } |
| |
| /** |
| * Slashes |
| */ |
| |
| if (value === '/') { |
| // if the beginning of the glob is "./", advance the start |
| // to the current index, and don't add the "./" characters |
| // to the state. This greatly simplifies lookbehinds when |
| // checking for BOS characters like "!" and "." (not "./") |
| if (prev.type === 'dot' && state.index === state.start + 1) { |
| state.start = state.index + 1; |
| state.consumed = ''; |
| state.output = ''; |
| tokens.pop(); |
| prev = bos; // reset "prev" to the first token |
| continue; |
| } |
| |
| push({ type: 'slash', value, output: SLASH_LITERAL }); |
| continue; |
| } |
| |
| /** |
| * Dots |
| */ |
| |
| if (value === '.') { |
| if (state.braces > 0 && prev.type === 'dot') { |
| if (prev.value === '.') prev.output = DOT_LITERAL; |
| const brace = braces[braces.length - 1]; |
| prev.type = 'dots'; |
| prev.output += value; |
| prev.value += value; |
| brace.dots = true; |
| continue; |
| } |
| |
| if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') { |
| push({ type: 'text', value, output: DOT_LITERAL }); |
| continue; |
| } |
| |
| push({ type: 'dot', value, output: DOT_LITERAL }); |
| continue; |
| } |
| |
| /** |
| * Question marks |
| */ |
| |
| if (value === '?') { |
| const isGroup = prev && prev.value === '('; |
| if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { |
| extglobOpen('qmark', value); |
| continue; |
| } |
| |
| if (prev && prev.type === 'paren') { |
| const next = peek(); |
| let output = value; |
| |
| if (next === '<' && !utils.supportsLookbehinds()) { |
| throw new Error('Node.js v10 or higher is required for regex lookbehinds'); |
| } |
| |
| if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) { |
| output = `\\${value}`; |
| } |
| |
| push({ type: 'text', value, output }); |
| continue; |
| } |
| |
| if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { |
| push({ type: 'qmark', value, output: QMARK_NO_DOT }); |
| continue; |
| } |
| |
| push({ type: 'qmark', value, output: QMARK }); |
| continue; |
| } |
| |
| /** |
| * Exclamation |
| */ |
| |
| if (value === '!') { |
| if (opts.noextglob !== true && peek() === '(') { |
| if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { |
| extglobOpen('negate', value); |
| continue; |
| } |
| } |
| |
| if (opts.nonegate !== true && state.index === 0) { |
| negate(); |
| continue; |
| } |
| } |
| |
| /** |
| * Plus |
| */ |
| |
| if (value === '+') { |
| if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { |
| extglobOpen('plus', value); |
| continue; |
| } |
| |
| if ((prev && prev.value === '(') || opts.regex === false) { |
| push({ type: 'plus', value, output: PLUS_LITERAL }); |
| continue; |
| } |
| |
| if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) { |
| push({ type: 'plus', value }); |
| continue; |
| } |
| |
| push({ type: 'plus', value: PLUS_LITERAL }); |
| continue; |
| } |
| |
| /** |
| * Plain text |
| */ |
| |
| if (value === '@') { |
| if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { |
| push({ type: 'at', extglob: true, value, output: '' }); |
| continue; |
| } |
| |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| /** |
| * Plain text |
| */ |
| |
| if (value !== '*') { |
| if (value === '$' || value === '^') { |
| value = `\\${value}`; |
| } |
| |
| const match = REGEX_NON_SPECIAL_CHARS.exec(remaining()); |
| if (match) { |
| value += match[0]; |
| state.index += match[0].length; |
| } |
| |
| push({ type: 'text', value }); |
| continue; |
| } |
| |
| /** |
| * Stars |
| */ |
| |
| if (prev && (prev.type === 'globstar' || prev.star === true)) { |
| prev.type = 'star'; |
| prev.star = true; |
| prev.value += value; |
| prev.output = star; |
| state.backtrack = true; |
| state.globstar = true; |
| consume(value); |
| continue; |
| } |
| |
| let rest = remaining(); |
| if (opts.noextglob !== true && /^\([^?]/.test(rest)) { |
| extglobOpen('star', value); |
| continue; |
| } |
| |
| if (prev.type === 'star') { |
| if (opts.noglobstar === true) { |
| consume(value); |
| continue; |
| } |
| |
| const prior = prev.prev; |
| const before = prior.prev; |
| const isStart = prior.type === 'slash' || prior.type === 'bos'; |
| const afterStar = before && (before.type === 'star' || before.type === 'globstar'); |
| |
| if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) { |
| push({ type: 'star', value, output: '' }); |
| continue; |
| } |
| |
| const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); |
| const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); |
| if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { |
| push({ type: 'star', value, output: '' }); |
| continue; |
| } |
| |
| // strip consecutive `/**/` |
| while (rest.slice(0, 3) === '/**') { |
| const after = input[state.index + 4]; |
| if (after && after !== '/') { |
| break; |
| } |
| rest = rest.slice(3); |
| consume('/**', 3); |
| } |
| |
| if (prior.type === 'bos' && eos()) { |
| prev.type = 'globstar'; |
| prev.value += value; |
| prev.output = globstar(opts); |
| state.output = prev.output; |
| state.globstar = true; |
| consume(value); |
| continue; |
| } |
| |
| if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { |
| state.output = state.output.slice(0, -(prior.output + prev.output).length); |
| prior.output = `(?:${prior.output}`; |
| |
| prev.type = 'globstar'; |
| prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)'); |
| prev.value += value; |
| state.globstar = true; |
| state.output += prior.output + prev.output; |
| consume(value); |
| continue; |
| } |
| |
| if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') { |
| const end = rest[1] !== void 0 ? '|$' : ''; |
| |
| state.output = state.output.slice(0, -(prior.output + prev.output).length); |
| prior.output = `(?:${prior.output}`; |
| |
| prev.type = 'globstar'; |
| prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; |
| prev.value += value; |
| |
| state.output += prior.output + prev.output; |
| state.globstar = true; |
| |
| consume(value + advance()); |
| |
| push({ type: 'slash', value: '/', output: '' }); |
| continue; |
| } |
| |
| if (prior.type === 'bos' && rest[0] === '/') { |
| prev.type = 'globstar'; |
| prev.value += value; |
| prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; |
| state.output = prev.output; |
| state.globstar = true; |
| consume(value + advance()); |
| push({ type: 'slash', value: '/', output: '' }); |
| continue; |
| } |
| |
| // remove single star from output |
| state.output = state.output.slice(0, -prev.output.length); |
| |
| // reset previous token to globstar |
| prev.type = 'globstar'; |
| prev.output = globstar(opts); |
| prev.value += value; |
| |
| // reset output with globstar |
| state.output += prev.output; |
| state.globstar = true; |
| consume(value); |
| continue; |
| } |
| |
| const token = { type: 'star', value, output: star }; |
| |
| if (opts.bash === true) { |
| token.output = '.*?'; |
| if (prev.type === 'bos' || prev.type === 'slash') { |
| token.output = nodot + token.output; |
| } |
| push(token); |
| continue; |
| } |
| |
| if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { |
| token.output = value; |
| push(token); |
| continue; |
| } |
| |
| if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { |
| if (prev.type === 'dot') { |
| state.output += NO_DOT_SLASH; |
| prev.output += NO_DOT_SLASH; |
| |
| } else if (opts.dot === true) { |
| state.output += NO_DOTS_SLASH; |
| prev.output += NO_DOTS_SLASH; |
| |
| } else { |
| state.output += nodot; |
| prev.output += nodot; |
| } |
| |
| if (peek() !== '*') { |
| state.output += ONE_CHAR; |
| prev.output += ONE_CHAR; |
| } |
| } |
| |
| push(token); |
| } |
| |
| while (state.brackets > 0) { |
| if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']')); |
| state.output = utils.escapeLast(state.output, '['); |
| decrement('brackets'); |
| } |
| |
| while (state.parens > 0) { |
| if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')')); |
| state.output = utils.escapeLast(state.output, '('); |
| decrement('parens'); |
| } |
| |
| while (state.braces > 0) { |
| if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}')); |
| state.output = utils.escapeLast(state.output, '{'); |
| decrement('braces'); |
| } |
| |
| if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { |
| push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` }); |
| } |
| |
| // rebuild the output if we had to backtrack at any point |
| if (state.backtrack === true) { |
| state.output = ''; |
| |
| for (const token of state.tokens) { |
| state.output += token.output != null ? token.output : token.value; |
| |
| if (token.suffix) { |
| state.output += token.suffix; |
| } |
| } |
| } |
| |
| return state; |
| }; |
| |
| /** |
| * Fast paths for creating regular expressions for common glob patterns. |
| * This can significantly speed up processing and has very little downside |
| * impact when none of the fast paths match. |
| */ |
| |
| parse.fastpaths = (input, options) => { |
| const opts = { ...options }; |
| const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; |
| const len = input.length; |
| if (len > max) { |
| throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); |
| } |
| |
| input = REPLACEMENTS[input] || input; |
| const win32 = utils.isWindows(options); |
| |
| // create constants based on platform, for windows or posix |
| const { |
| DOT_LITERAL, |
| SLASH_LITERAL, |
| ONE_CHAR, |
| DOTS_SLASH, |
| NO_DOT, |
| NO_DOTS, |
| NO_DOTS_SLASH, |
| STAR, |
| START_ANCHOR |
| } = constants.globChars(win32); |
| |
| const nodot = opts.dot ? NO_DOTS : NO_DOT; |
| const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; |
| const capture = opts.capture ? '' : '?:'; |
| const state = { negated: false, prefix: '' }; |
| let star = opts.bash === true ? '.*?' : STAR; |
| |
| if (opts.capture) { |
| star = `(${star})`; |
| } |
| |
| const globstar = (opts) => { |
| if (opts.noglobstar === true) return star; |
| return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; |
| }; |
| |
| const create = str => { |
| switch (str) { |
| case '*': |
| return `${nodot}${ONE_CHAR}${star}`; |
| |
| case '.*': |
| return `${DOT_LITERAL}${ONE_CHAR}${star}`; |
| |
| case '*.*': |
| return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; |
| |
| case '*/*': |
| return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; |
| |
| case '**': |
| return nodot + globstar(opts); |
| |
| case '**/*': |
| return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; |
| |
| case '**/*.*': |
| return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; |
| |
| case '**/.*': |
| return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; |
| |
| default: { |
| const match = /^(.*?)\.(\w+)$/.exec(str); |
| if (!match) return; |
| |
| const source = create(match[1]); |
| if (!source) return; |
| |
| return source + DOT_LITERAL + match[2]; |
| } |
| } |
| }; |
| |
| const output = utils.removePrefix(input, state); |
| let source = create(output); |
| |
| if (source && opts.strictSlashes !== true) { |
| source += `${SLASH_LITERAL}?`; |
| } |
| |
| return source; |
| }; |
| |
| module.exports = parse; |
| |
| |
| /***/ }), |
| |
| /***/ 3322: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const path = __nccwpck_require__(5622); |
| const scan = __nccwpck_require__(2429); |
| const parse = __nccwpck_require__(2139); |
| const utils = __nccwpck_require__(479); |
| const constants = __nccwpck_require__(6099); |
| const isObject = val => val && typeof val === 'object' && !Array.isArray(val); |
| |
| /** |
| * Creates a matcher function from one or more glob patterns. The |
| * returned function takes a string to match as its first argument, |
| * and returns true if the string is a match. The returned matcher |
| * function also takes a boolean as the second argument that, when true, |
| * returns an object with additional information. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch(glob[, options]); |
| * |
| * const isMatch = picomatch('*.!(*a)'); |
| * console.log(isMatch('a.a')); //=> false |
| * console.log(isMatch('a.b')); //=> true |
| * ``` |
| * @name picomatch |
| * @param {String|Array} `globs` One or more glob patterns. |
| * @param {Object=} `options` |
| * @return {Function=} Returns a matcher function. |
| * @api public |
| */ |
| |
| const picomatch = (glob, options, returnState = false) => { |
| if (Array.isArray(glob)) { |
| const fns = glob.map(input => picomatch(input, options, returnState)); |
| const arrayMatcher = str => { |
| for (const isMatch of fns) { |
| const state = isMatch(str); |
| if (state) return state; |
| } |
| return false; |
| }; |
| return arrayMatcher; |
| } |
| |
| const isState = isObject(glob) && glob.tokens && glob.input; |
| |
| if (glob === '' || (typeof glob !== 'string' && !isState)) { |
| throw new TypeError('Expected pattern to be a non-empty string'); |
| } |
| |
| const opts = options || {}; |
| const posix = utils.isWindows(options); |
| const regex = isState |
| ? picomatch.compileRe(glob, options) |
| : picomatch.makeRe(glob, options, false, true); |
| |
| const state = regex.state; |
| delete regex.state; |
| |
| let isIgnored = () => false; |
| if (opts.ignore) { |
| const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null }; |
| isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); |
| } |
| |
| const matcher = (input, returnObject = false) => { |
| const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }); |
| const result = { glob, state, regex, posix, input, output, match, isMatch }; |
| |
| if (typeof opts.onResult === 'function') { |
| opts.onResult(result); |
| } |
| |
| if (isMatch === false) { |
| result.isMatch = false; |
| return returnObject ? result : false; |
| } |
| |
| if (isIgnored(input)) { |
| if (typeof opts.onIgnore === 'function') { |
| opts.onIgnore(result); |
| } |
| result.isMatch = false; |
| return returnObject ? result : false; |
| } |
| |
| if (typeof opts.onMatch === 'function') { |
| opts.onMatch(result); |
| } |
| return returnObject ? result : true; |
| }; |
| |
| if (returnState) { |
| matcher.state = state; |
| } |
| |
| return matcher; |
| }; |
| |
| /** |
| * Test `input` with the given `regex`. This is used by the main |
| * `picomatch()` function to test the input string. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch.test(input, regex[, options]); |
| * |
| * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); |
| * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } |
| * ``` |
| * @param {String} `input` String to test. |
| * @param {RegExp} `regex` |
| * @return {Object} Returns an object with matching info. |
| * @api public |
| */ |
| |
| picomatch.test = (input, regex, options, { glob, posix } = {}) => { |
| if (typeof input !== 'string') { |
| throw new TypeError('Expected input to be a string'); |
| } |
| |
| if (input === '') { |
| return { isMatch: false, output: '' }; |
| } |
| |
| const opts = options || {}; |
| const format = opts.format || (posix ? utils.toPosixSlashes : null); |
| let match = input === glob; |
| let output = (match && format) ? format(input) : input; |
| |
| if (match === false) { |
| output = format ? format(input) : input; |
| match = output === glob; |
| } |
| |
| if (match === false || opts.capture === true) { |
| if (opts.matchBase === true || opts.basename === true) { |
| match = picomatch.matchBase(input, regex, options, posix); |
| } else { |
| match = regex.exec(output); |
| } |
| } |
| |
| return { isMatch: Boolean(match), match, output }; |
| }; |
| |
| /** |
| * Match the basename of a filepath. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch.matchBase(input, glob[, options]); |
| * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true |
| * ``` |
| * @param {String} `input` String to test. |
| * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). |
| * @return {Boolean} |
| * @api public |
| */ |
| |
| picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => { |
| const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); |
| return regex.test(path.basename(input)); |
| }; |
| |
| /** |
| * Returns true if **any** of the given glob `patterns` match the specified `string`. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch.isMatch(string, patterns[, options]); |
| * |
| * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true |
| * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false |
| * ``` |
| * @param {String|Array} str The string to test. |
| * @param {String|Array} patterns One or more glob patterns to use for matching. |
| * @param {Object} [options] See available [options](#options). |
| * @return {Boolean} Returns true if any patterns match `str` |
| * @api public |
| */ |
| |
| picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); |
| |
| /** |
| * Parse a glob pattern to create the source string for a regular |
| * expression. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * const result = picomatch.parse(pattern[, options]); |
| * ``` |
| * @param {String} `pattern` |
| * @param {Object} `options` |
| * @return {Object} Returns an object with useful properties and output to be used as a regex source string. |
| * @api public |
| */ |
| |
| picomatch.parse = (pattern, options) => { |
| if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options)); |
| return parse(pattern, { ...options, fastpaths: false }); |
| }; |
| |
| /** |
| * Scan a glob pattern to separate the pattern into segments. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch.scan(input[, options]); |
| * |
| * const result = picomatch.scan('!./foo/*.js'); |
| * console.log(result); |
| * { prefix: '!./', |
| * input: '!./foo/*.js', |
| * start: 3, |
| * base: 'foo', |
| * glob: '*.js', |
| * isBrace: false, |
| * isBracket: false, |
| * isGlob: true, |
| * isExtglob: false, |
| * isGlobstar: false, |
| * negated: true } |
| * ``` |
| * @param {String} `input` Glob pattern to scan. |
| * @param {Object} `options` |
| * @return {Object} Returns an object with |
| * @api public |
| */ |
| |
| picomatch.scan = (input, options) => scan(input, options); |
| |
| /** |
| * Create a regular expression from a parsed glob pattern. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * const state = picomatch.parse('*.js'); |
| * // picomatch.compileRe(state[, options]); |
| * |
| * console.log(picomatch.compileRe(state)); |
| * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ |
| * ``` |
| * @param {String} `state` The object returned from the `.parse` method. |
| * @param {Object} `options` |
| * @return {RegExp} Returns a regex created from the given pattern. |
| * @api public |
| */ |
| |
| picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => { |
| if (returnOutput === true) { |
| return parsed.output; |
| } |
| |
| const opts = options || {}; |
| const prepend = opts.contains ? '' : '^'; |
| const append = opts.contains ? '' : '$'; |
| |
| let source = `${prepend}(?:${parsed.output})${append}`; |
| if (parsed && parsed.negated === true) { |
| source = `^(?!${source}).*$`; |
| } |
| |
| const regex = picomatch.toRegex(source, options); |
| if (returnState === true) { |
| regex.state = parsed; |
| } |
| |
| return regex; |
| }; |
| |
| picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => { |
| if (!input || typeof input !== 'string') { |
| throw new TypeError('Expected a non-empty string'); |
| } |
| |
| const opts = options || {}; |
| let parsed = { negated: false, fastpaths: true }; |
| let prefix = ''; |
| let output; |
| |
| if (input.startsWith('./')) { |
| input = input.slice(2); |
| prefix = parsed.prefix = './'; |
| } |
| |
| if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { |
| output = parse.fastpaths(input, options); |
| } |
| |
| if (output === undefined) { |
| parsed = parse(input, options); |
| parsed.prefix = prefix + (parsed.prefix || ''); |
| } else { |
| parsed.output = output; |
| } |
| |
| return picomatch.compileRe(parsed, options, returnOutput, returnState); |
| }; |
| |
| /** |
| * Create a regular expression from the given regex source string. |
| * |
| * ```js |
| * const picomatch = require('picomatch'); |
| * // picomatch.toRegex(source[, options]); |
| * |
| * const { output } = picomatch.parse('*.js'); |
| * console.log(picomatch.toRegex(output)); |
| * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ |
| * ``` |
| * @param {String} `source` Regular expression source string. |
| * @param {Object} `options` |
| * @return {RegExp} |
| * @api public |
| */ |
| |
| picomatch.toRegex = (source, options) => { |
| try { |
| const opts = options || {}; |
| return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); |
| } catch (err) { |
| if (options && options.debug === true) throw err; |
| return /$^/; |
| } |
| }; |
| |
| /** |
| * Picomatch constants. |
| * @return {Object} |
| */ |
| |
| picomatch.constants = constants; |
| |
| /** |
| * Expose "picomatch" |
| */ |
| |
| module.exports = picomatch; |
| |
| |
| /***/ }), |
| |
| /***/ 2429: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const utils = __nccwpck_require__(479); |
| const { |
| CHAR_ASTERISK, /* * */ |
| CHAR_AT, /* @ */ |
| CHAR_BACKWARD_SLASH, /* \ */ |
| CHAR_COMMA, /* , */ |
| CHAR_DOT, /* . */ |
| CHAR_EXCLAMATION_MARK, /* ! */ |
| CHAR_FORWARD_SLASH, /* / */ |
| CHAR_LEFT_CURLY_BRACE, /* { */ |
| CHAR_LEFT_PARENTHESES, /* ( */ |
| CHAR_LEFT_SQUARE_BRACKET, /* [ */ |
| CHAR_PLUS, /* + */ |
| CHAR_QUESTION_MARK, /* ? */ |
| CHAR_RIGHT_CURLY_BRACE, /* } */ |
| CHAR_RIGHT_PARENTHESES, /* ) */ |
| CHAR_RIGHT_SQUARE_BRACKET /* ] */ |
| } = __nccwpck_require__(6099); |
| |
| const isPathSeparator = code => { |
| return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; |
| }; |
| |
| const depth = token => { |
| if (token.isPrefix !== true) { |
| token.depth = token.isGlobstar ? Infinity : 1; |
| } |
| }; |
| |
| /** |
| * Quickly scans a glob pattern and returns an object with a handful of |
| * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), |
| * `glob` (the actual pattern), and `negated` (true if the path starts with `!`). |
| * |
| * ```js |
| * const pm = require('picomatch'); |
| * console.log(pm.scan('foo/bar/*.js')); |
| * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } |
| * ``` |
| * @param {String} `str` |
| * @param {Object} `options` |
| * @return {Object} Returns an object with tokens and regex source string. |
| * @api public |
| */ |
| |
| const scan = (input, options) => { |
| const opts = options || {}; |
| |
| const length = input.length - 1; |
| const scanToEnd = opts.parts === true || opts.scanToEnd === true; |
| const slashes = []; |
| const tokens = []; |
| const parts = []; |
| |
| let str = input; |
| let index = -1; |
| let start = 0; |
| let lastIndex = 0; |
| let isBrace = false; |
| let isBracket = false; |
| let isGlob = false; |
| let isExtglob = false; |
| let isGlobstar = false; |
| let braceEscaped = false; |
| let backslashes = false; |
| let negated = false; |
| let finished = false; |
| let braces = 0; |
| let prev; |
| let code; |
| let token = { value: '', depth: 0, isGlob: false }; |
| |
| const eos = () => index >= length; |
| const peek = () => str.charCodeAt(index + 1); |
| const advance = () => { |
| prev = code; |
| return str.charCodeAt(++index); |
| }; |
| |
| while (index < length) { |
| code = advance(); |
| let next; |
| |
| if (code === CHAR_BACKWARD_SLASH) { |
| backslashes = token.backslashes = true; |
| code = advance(); |
| |
| if (code === CHAR_LEFT_CURLY_BRACE) { |
| braceEscaped = true; |
| } |
| continue; |
| } |
| |
| if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) { |
| braces++; |
| |
| while (eos() !== true && (code = advance())) { |
| if (code === CHAR_BACKWARD_SLASH) { |
| backslashes = token.backslashes = true; |
| advance(); |
| continue; |
| } |
| |
| if (code === CHAR_LEFT_CURLY_BRACE) { |
| braces++; |
| continue; |
| } |
| |
| if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) { |
| isBrace = token.isBrace = true; |
| isGlob = token.isGlob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| |
| break; |
| } |
| |
| if (braceEscaped !== true && code === CHAR_COMMA) { |
| isBrace = token.isBrace = true; |
| isGlob = token.isGlob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| |
| break; |
| } |
| |
| if (code === CHAR_RIGHT_CURLY_BRACE) { |
| braces--; |
| |
| if (braces === 0) { |
| braceEscaped = false; |
| isBrace = token.isBrace = true; |
| finished = true; |
| break; |
| } |
| } |
| } |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| |
| break; |
| } |
| |
| if (code === CHAR_FORWARD_SLASH) { |
| slashes.push(index); |
| tokens.push(token); |
| token = { value: '', depth: 0, isGlob: false }; |
| |
| if (finished === true) continue; |
| if (prev === CHAR_DOT && index === (start + 1)) { |
| start += 2; |
| continue; |
| } |
| |
| lastIndex = index + 1; |
| continue; |
| } |
| |
| if (opts.noext !== true) { |
| const isExtglobChar = code === CHAR_PLUS |
| || code === CHAR_AT |
| || code === CHAR_ASTERISK |
| || code === CHAR_QUESTION_MARK |
| || code === CHAR_EXCLAMATION_MARK; |
| |
| if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) { |
| isGlob = token.isGlob = true; |
| isExtglob = token.isExtglob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| while (eos() !== true && (code = advance())) { |
| if (code === CHAR_BACKWARD_SLASH) { |
| backslashes = token.backslashes = true; |
| code = advance(); |
| continue; |
| } |
| |
| if (code === CHAR_RIGHT_PARENTHESES) { |
| isGlob = token.isGlob = true; |
| finished = true; |
| break; |
| } |
| } |
| continue; |
| } |
| break; |
| } |
| } |
| |
| if (code === CHAR_ASTERISK) { |
| if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true; |
| isGlob = token.isGlob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| break; |
| } |
| |
| if (code === CHAR_QUESTION_MARK) { |
| isGlob = token.isGlob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| break; |
| } |
| |
| if (code === CHAR_LEFT_SQUARE_BRACKET) { |
| while (eos() !== true && (next = advance())) { |
| if (next === CHAR_BACKWARD_SLASH) { |
| backslashes = token.backslashes = true; |
| advance(); |
| continue; |
| } |
| |
| if (next === CHAR_RIGHT_SQUARE_BRACKET) { |
| isBracket = token.isBracket = true; |
| isGlob = token.isGlob = true; |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| break; |
| } |
| } |
| } |
| |
| if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) { |
| negated = token.negated = true; |
| start++; |
| continue; |
| } |
| |
| if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) { |
| isGlob = token.isGlob = true; |
| |
| if (scanToEnd === true) { |
| while (eos() !== true && (code = advance())) { |
| if (code === CHAR_LEFT_PARENTHESES) { |
| backslashes = token.backslashes = true; |
| code = advance(); |
| continue; |
| } |
| |
| if (code === CHAR_RIGHT_PARENTHESES) { |
| finished = true; |
| break; |
| } |
| } |
| continue; |
| } |
| break; |
| } |
| |
| if (isGlob === true) { |
| finished = true; |
| |
| if (scanToEnd === true) { |
| continue; |
| } |
| |
| break; |
| } |
| } |
| |
| if (opts.noext === true) { |
| isExtglob = false; |
| isGlob = false; |
| } |
| |
| let base = str; |
| let prefix = ''; |
| let glob = ''; |
| |
| if (start > 0) { |
| prefix = str.slice(0, start); |
| str = str.slice(start); |
| lastIndex -= start; |
| } |
| |
| if (base && isGlob === true && lastIndex > 0) { |
| base = str.slice(0, lastIndex); |
| glob = str.slice(lastIndex); |
| } else if (isGlob === true) { |
| base = ''; |
| glob = str; |
| } else { |
| base = str; |
| } |
| |
| if (base && base !== '' && base !== '/' && base !== str) { |
| if (isPathSeparator(base.charCodeAt(base.length - 1))) { |
| base = base.slice(0, -1); |
| } |
| } |
| |
| if (opts.unescape === true) { |
| if (glob) glob = utils.removeBackslashes(glob); |
| |
| if (base && backslashes === true) { |
| base = utils.removeBackslashes(base); |
| } |
| } |
| |
| const state = { |
| prefix, |
| input, |
| start, |
| base, |
| glob, |
| isBrace, |
| isBracket, |
| isGlob, |
| isExtglob, |
| isGlobstar, |
| negated |
| }; |
| |
| if (opts.tokens === true) { |
| state.maxDepth = 0; |
| if (!isPathSeparator(code)) { |
| tokens.push(token); |
| } |
| state.tokens = tokens; |
| } |
| |
| if (opts.parts === true || opts.tokens === true) { |
| let prevIndex; |
| |
| for (let idx = 0; idx < slashes.length; idx++) { |
| const n = prevIndex ? prevIndex + 1 : start; |
| const i = slashes[idx]; |
| const value = input.slice(n, i); |
| if (opts.tokens) { |
| if (idx === 0 && start !== 0) { |
| tokens[idx].isPrefix = true; |
| tokens[idx].value = prefix; |
| } else { |
| tokens[idx].value = value; |
| } |
| depth(tokens[idx]); |
| state.maxDepth += tokens[idx].depth; |
| } |
| if (idx !== 0 || value !== '') { |
| parts.push(value); |
| } |
| prevIndex = i; |
| } |
| |
| if (prevIndex && prevIndex + 1 < input.length) { |
| const value = input.slice(prevIndex + 1); |
| parts.push(value); |
| |
| if (opts.tokens) { |
| tokens[tokens.length - 1].value = value; |
| depth(tokens[tokens.length - 1]); |
| state.maxDepth += tokens[tokens.length - 1].depth; |
| } |
| } |
| |
| state.slashes = slashes; |
| state.parts = parts; |
| } |
| |
| return state; |
| }; |
| |
| module.exports = scan; |
| |
| |
| /***/ }), |
| |
| /***/ 479: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const path = __nccwpck_require__(5622); |
| const win32 = process.platform === 'win32'; |
| const { |
| REGEX_BACKSLASH, |
| REGEX_REMOVE_BACKSLASH, |
| REGEX_SPECIAL_CHARS, |
| REGEX_SPECIAL_CHARS_GLOBAL |
| } = __nccwpck_require__(6099); |
| |
| exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); |
| exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); |
| exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); |
| exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); |
| exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/'); |
| |
| exports.removeBackslashes = str => { |
| return str.replace(REGEX_REMOVE_BACKSLASH, match => { |
| return match === '\\' ? '' : match; |
| }); |
| }; |
| |
| exports.supportsLookbehinds = () => { |
| const segs = process.version.slice(1).split('.').map(Number); |
| if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) { |
| return true; |
| } |
| return false; |
| }; |
| |
| exports.isWindows = options => { |
| if (options && typeof options.windows === 'boolean') { |
| return options.windows; |
| } |
| return win32 === true || path.sep === '\\'; |
| }; |
| |
| exports.escapeLast = (input, char, lastIdx) => { |
| const idx = input.lastIndexOf(char, lastIdx); |
| if (idx === -1) return input; |
| if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1); |
| return `${input.slice(0, idx)}\\${input.slice(idx)}`; |
| }; |
| |
| exports.removePrefix = (input, state = {}) => { |
| let output = input; |
| if (output.startsWith('./')) { |
| output = output.slice(2); |
| state.prefix = './'; |
| } |
| return output; |
| }; |
| |
| exports.wrapOutput = (input, state = {}, options = {}) => { |
| const prepend = options.contains ? '' : '^'; |
| const append = options.contains ? '' : '$'; |
| |
| let output = `${prepend}(?:${input})${append}`; |
| if (state.negated === true) { |
| output = `(?:^(?!${output}).*$)`; |
| } |
| return output; |
| }; |
| |
| |
| /***/ }), |
| |
| /***/ 8341: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| var once = __nccwpck_require__(1223) |
| var eos = __nccwpck_require__(1205) |
| var fs = __nccwpck_require__(5747) // we only need fs to get the ReadStream and WriteStream prototypes |
| |
| var noop = function () {} |
| var ancient = /^v?\.0/.test(process.version) |
| |
| var isFn = function (fn) { |
| return typeof fn === 'function' |
| } |
| |
| var isFS = function (stream) { |
| if (!ancient) return false // newer node version do not need to care about fs is a special way |
| if (!fs) return false // browser |
| return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close) |
| } |
| |
| var isRequest = function (stream) { |
| return stream.setHeader && isFn(stream.abort) |
| } |
| |
| var destroyer = function (stream, reading, writing, callback) { |
| callback = once(callback) |
| |
| var closed = false |
| stream.on('close', function () { |
| closed = true |
| }) |
| |
| eos(stream, {readable: reading, writable: writing}, function (err) { |
| if (err) return callback(err) |
| closed = true |
| callback() |
| }) |
| |
| var destroyed = false |
| return function (err) { |
| if (closed) return |
| if (destroyed) return |
| destroyed = true |
| |
| if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks |
| if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want |
| |
| if (isFn(stream.destroy)) return stream.destroy() |
| |
| callback(err || new Error('stream was destroyed')) |
| } |
| } |
| |
| var call = function (fn) { |
| fn() |
| } |
| |
| var pipe = function (from, to) { |
| return from.pipe(to) |
| } |
| |
| var pump = function () { |
| var streams = Array.prototype.slice.call(arguments) |
| var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop |
| |
| if (Array.isArray(streams[0])) streams = streams[0] |
| if (streams.length < 2) throw new Error('pump requires two streams per minimum') |
| |
| var error |
| var destroys = streams.map(function (stream, i) { |
| var reading = i < streams.length - 1 |
| var writing = i > 0 |
| return destroyer(stream, reading, writing, function (err) { |
| if (!error) error = err |
| if (err) destroys.forEach(call) |
| if (reading) return |
| destroys.forEach(call) |
| callback(error) |
| }) |
| }) |
| |
| return streams.reduce(pipe) |
| } |
| |
| module.exports = pump |
| |
| |
| /***/ }), |
| |
| /***/ 9273: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| class QuickLRU { |
| constructor(options = {}) { |
| if (!(options.maxSize && options.maxSize > 0)) { |
| throw new TypeError('`maxSize` must be a number greater than 0'); |
| } |
| |
| this.maxSize = options.maxSize; |
| this.onEviction = options.onEviction; |
| this.cache = new Map(); |
| this.oldCache = new Map(); |
| this._size = 0; |
| } |
| |
| _set(key, value) { |
| this.cache.set(key, value); |
| this._size++; |
| |
| if (this._size >= this.maxSize) { |
| this._size = 0; |
| |
| if (typeof this.onEviction === 'function') { |
| for (const [key, value] of this.oldCache.entries()) { |
| this.onEviction(key, value); |
| } |
| } |
| |
| this.oldCache = this.cache; |
| this.cache = new Map(); |
| } |
| } |
| |
| get(key) { |
| if (this.cache.has(key)) { |
| return this.cache.get(key); |
| } |
| |
| if (this.oldCache.has(key)) { |
| const value = this.oldCache.get(key); |
| this.oldCache.delete(key); |
| this._set(key, value); |
| return value; |
| } |
| } |
| |
| set(key, value) { |
| if (this.cache.has(key)) { |
| this.cache.set(key, value); |
| } else { |
| this._set(key, value); |
| } |
| |
| return this; |
| } |
| |
| has(key) { |
| return this.cache.has(key) || this.oldCache.has(key); |
| } |
| |
| peek(key) { |
| if (this.cache.has(key)) { |
| return this.cache.get(key); |
| } |
| |
| if (this.oldCache.has(key)) { |
| return this.oldCache.get(key); |
| } |
| } |
| |
| delete(key) { |
| const deleted = this.cache.delete(key); |
| if (deleted) { |
| this._size--; |
| } |
| |
| return this.oldCache.delete(key) || deleted; |
| } |
| |
| clear() { |
| this.cache.clear(); |
| this.oldCache.clear(); |
| this._size = 0; |
| } |
| |
| * keys() { |
| for (const [key] of this) { |
| yield key; |
| } |
| } |
| |
| * values() { |
| for (const [, value] of this) { |
| yield value; |
| } |
| } |
| |
| * [Symbol.iterator]() { |
| for (const item of this.cache) { |
| yield item; |
| } |
| |
| for (const item of this.oldCache) { |
| const [key] = item; |
| if (!this.cache.has(key)) { |
| yield item; |
| } |
| } |
| } |
| |
| get size() { |
| let oldCacheSize = 0; |
| for (const key of this.oldCache.keys()) { |
| if (!this.cache.has(key)) { |
| oldCacheSize++; |
| } |
| } |
| |
| return Math.min(this._size + oldCacheSize, this.maxSize); |
| } |
| } |
| |
| module.exports = QuickLRU; |
| |
| |
| /***/ }), |
| |
| /***/ 6624: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| const tls = __nccwpck_require__(4016); |
| |
| module.exports = (options = {}) => new Promise((resolve, reject) => { |
| const socket = tls.connect(options, () => { |
| if (options.resolveSocket) { |
| socket.off('error', reject); |
| resolve({alpnProtocol: socket.alpnProtocol, socket}); |
| } else { |
| socket.destroy(); |
| resolve({alpnProtocol: socket.alpnProtocol}); |
| } |
| }); |
| |
| socket.on('error', reject); |
| }); |
| |
| |
| /***/ }), |
| |
| /***/ 9004: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| const Readable = __nccwpck_require__(2413).Readable; |
| const lowercaseKeys = __nccwpck_require__(9662); |
| |
| class Response extends Readable { |
| constructor(statusCode, headers, body, url) { |
| if (typeof statusCode !== 'number') { |
| throw new TypeError('Argument `statusCode` should be a number'); |
| } |
| if (typeof headers !== 'object') { |
| throw new TypeError('Argument `headers` should be an object'); |
| } |
| if (!(body instanceof Buffer)) { |
| throw new TypeError('Argument `body` should be a buffer'); |
| } |
| if (typeof url !== 'string') { |
| throw new TypeError('Argument `url` should be a string'); |
| } |
| |
| super(); |
| this.statusCode = statusCode; |
| this.headers = lowercaseKeys(headers); |
| this.body = body; |
| this.url = url; |
| } |
| |
| _read() { |
| this.push(this.body); |
| this.push(null); |
| } |
| } |
| |
| module.exports = Response; |
| |
| |
| /***/ }), |
| |
| /***/ 2113: |
| /***/ ((module) => { |
| |
| "use strict"; |
| |
| |
| function reusify (Constructor) { |
| var head = new Constructor() |
| var tail = head |
| |
| function get () { |
| var current = head |
| |
| if (current.next) { |
| head = current.next |
| } else { |
| head = new Constructor() |
| tail = head |
| } |
| |
| current.next = null |
| |
| return current |
| } |
| |
| function release (obj) { |
| tail.next = obj |
| tail = obj |
| } |
| |
| return { |
| get: get, |
| release: release |
| } |
| } |
| |
| module.exports = reusify |
| |
| |
| /***/ }), |
| |
| /***/ 5288: |
| /***/ ((module) => { |
| |
| /*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */ |
| module.exports = runParallel |
| |
| function runParallel (tasks, cb) { |
| var results, pending, keys |
| var isSync = true |
| |
| if (Array.isArray(tasks)) { |
| results = [] |
| pending = tasks.length |
| } else { |
| keys = Object.keys(tasks) |
| results = {} |
| pending = keys.length |
| } |
| |
| function done (err) { |
| function end () { |
| if (cb) cb(err, results) |
| cb = null |
| } |
| if (isSync) process.nextTick(end) |
| else end() |
| } |
| |
| function each (i, err, result) { |
| results[i] = result |
| if (--pending === 0 || err) { |
| done(err) |
| } |
| } |
| |
| if (!pending) { |
| // empty |
| done(null) |
| } else if (keys) { |
| // object |
| keys.forEach(function (key) { |
| tasks[key](function (err, result) { each(key, err, result) }) |
| }) |
| } else { |
| // array |
| tasks.forEach(function (task, i) { |
| task(function (err, result) { each(i, err, result) }) |
| }) |
| } |
| |
| isSync = false |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2043: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| ;(function (sax) { // wrapper for non-node envs |
| sax.parser = function (strict, opt) { return new SAXParser(strict, opt) } |
| sax.SAXParser = SAXParser |
| sax.SAXStream = SAXStream |
| sax.createStream = createStream |
| |
| // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns. |
| // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)), |
| // since that's the earliest that a buffer overrun could occur. This way, checks are |
| // as rare as required, but as often as necessary to ensure never crossing this bound. |
| // Furthermore, buffers are only tested at most once per write(), so passing a very |
| // large string into write() might have undesirable effects, but this is manageable by |
| // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme |
| // edge case, result in creating at most one complete copy of the string passed in. |
| // Set to Infinity to have unlimited buffers. |
| sax.MAX_BUFFER_LENGTH = 64 * 1024 |
| |
| var buffers = [ |
| 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype', |
| 'procInstName', 'procInstBody', 'entity', 'attribName', |
| 'attribValue', 'cdata', 'script' |
| ] |
| |
| sax.EVENTS = [ |
| 'text', |
| 'processinginstruction', |
| 'sgmldeclaration', |
| 'doctype', |
| 'comment', |
| 'opentagstart', |
| 'attribute', |
| 'opentag', |
| 'closetag', |
| 'opencdata', |
| 'cdata', |
| 'closecdata', |
| 'error', |
| 'end', |
| 'ready', |
| 'script', |
| 'opennamespace', |
| 'closenamespace' |
| ] |
| |
| function SAXParser (strict, opt) { |
| if (!(this instanceof SAXParser)) { |
| return new SAXParser(strict, opt) |
| } |
| |
| var parser = this |
| clearBuffers(parser) |
| parser.q = parser.c = '' |
| parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH |
| parser.opt = opt || {} |
| parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags |
| parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase' |
| parser.tags = [] |
| parser.closed = parser.closedRoot = parser.sawRoot = false |
| parser.tag = parser.error = null |
| parser.strict = !!strict |
| parser.noscript = !!(strict || parser.opt.noscript) |
| parser.state = S.BEGIN |
| parser.strictEntities = parser.opt.strictEntities |
| parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES) |
| parser.attribList = [] |
| |
| // namespaces form a prototype chain. |
| // it always points at the current tag, |
| // which protos to its parent tag. |
| if (parser.opt.xmlns) { |
| parser.ns = Object.create(rootNS) |
| } |
| |
| // mostly just for error reporting |
| parser.trackPosition = parser.opt.position !== false |
| if (parser.trackPosition) { |
| parser.position = parser.line = parser.column = 0 |
| } |
| emit(parser, 'onready') |
| } |
| |
| if (!Object.create) { |
| Object.create = function (o) { |
| function F () {} |
| F.prototype = o |
| var newf = new F() |
| return newf |
| } |
| } |
| |
| if (!Object.keys) { |
| Object.keys = function (o) { |
| var a = [] |
| for (var i in o) if (o.hasOwnProperty(i)) a.push(i) |
| return a |
| } |
| } |
| |
| function checkBufferLength (parser) { |
| var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10) |
| var maxActual = 0 |
| for (var i = 0, l = buffers.length; i < l; i++) { |
| var len = parser[buffers[i]].length |
| if (len > maxAllowed) { |
| // Text/cdata nodes can get big, and since they're buffered, |
| // we can get here under normal conditions. |
| // Avoid issues by emitting the text node now, |
| // so at least it won't get any bigger. |
| switch (buffers[i]) { |
| case 'textNode': |
| closeText(parser) |
| break |
| |
| case 'cdata': |
| emitNode(parser, 'oncdata', parser.cdata) |
| parser.cdata = '' |
| break |
| |
| case 'script': |
| emitNode(parser, 'onscript', parser.script) |
| parser.script = '' |
| break |
| |
| default: |
| error(parser, 'Max buffer length exceeded: ' + buffers[i]) |
| } |
| } |
| maxActual = Math.max(maxActual, len) |
| } |
| // schedule the next check for the earliest possible buffer overrun. |
| var m = sax.MAX_BUFFER_LENGTH - maxActual |
| parser.bufferCheckPosition = m + parser.position |
| } |
| |
| function clearBuffers (parser) { |
| for (var i = 0, l = buffers.length; i < l; i++) { |
| parser[buffers[i]] = '' |
| } |
| } |
| |
| function flushBuffers (parser) { |
| closeText(parser) |
| if (parser.cdata !== '') { |
| emitNode(parser, 'oncdata', parser.cdata) |
| parser.cdata = '' |
| } |
| if (parser.script !== '') { |
| emitNode(parser, 'onscript', parser.script) |
| parser.script = '' |
| } |
| } |
| |
| SAXParser.prototype = { |
| end: function () { end(this) }, |
| write: write, |
| resume: function () { this.error = null; return this }, |
| close: function () { return this.write(null) }, |
| flush: function () { flushBuffers(this) } |
| } |
| |
| var Stream |
| try { |
| Stream = __nccwpck_require__(2413).Stream |
| } catch (ex) { |
| Stream = function () {} |
| } |
| |
| var streamWraps = sax.EVENTS.filter(function (ev) { |
| return ev !== 'error' && ev !== 'end' |
| }) |
| |
| function createStream (strict, opt) { |
| return new SAXStream(strict, opt) |
| } |
| |
| function SAXStream (strict, opt) { |
| if (!(this instanceof SAXStream)) { |
| return new SAXStream(strict, opt) |
| } |
| |
| Stream.apply(this) |
| |
| this._parser = new SAXParser(strict, opt) |
| this.writable = true |
| this.readable = true |
| |
| var me = this |
| |
| this._parser.onend = function () { |
| me.emit('end') |
| } |
| |
| this._parser.onerror = function (er) { |
| me.emit('error', er) |
| |
| // if didn't throw, then means error was handled. |
| // go ahead and clear error, so we can write again. |
| me._parser.error = null |
| } |
| |
| this._decoder = null |
| |
| streamWraps.forEach(function (ev) { |
| Object.defineProperty(me, 'on' + ev, { |
| get: function () { |
| return me._parser['on' + ev] |
| }, |
| set: function (h) { |
| if (!h) { |
| me.removeAllListeners(ev) |
| me._parser['on' + ev] = h |
| return h |
| } |
| me.on(ev, h) |
| }, |
| enumerable: true, |
| configurable: false |
| }) |
| }) |
| } |
| |
| SAXStream.prototype = Object.create(Stream.prototype, { |
| constructor: { |
| value: SAXStream |
| } |
| }) |
| |
| SAXStream.prototype.write = function (data) { |
| if (typeof Buffer === 'function' && |
| typeof Buffer.isBuffer === 'function' && |
| Buffer.isBuffer(data)) { |
| if (!this._decoder) { |
| var SD = __nccwpck_require__(4304).StringDecoder |
| this._decoder = new SD('utf8') |
| } |
| data = this._decoder.write(data) |
| } |
| |
| this._parser.write(data.toString()) |
| this.emit('data', data) |
| return true |
| } |
| |
| SAXStream.prototype.end = function (chunk) { |
| if (chunk && chunk.length) { |
| this.write(chunk) |
| } |
| this._parser.end() |
| return true |
| } |
| |
| SAXStream.prototype.on = function (ev, handler) { |
| var me = this |
| if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) { |
| me._parser['on' + ev] = function () { |
| var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments) |
| args.splice(0, 0, ev) |
| me.emit.apply(me, args) |
| } |
| } |
| |
| return Stream.prototype.on.call(me, ev, handler) |
| } |
| |
| // this really needs to be replaced with character classes. |
| // XML allows all manner of ridiculous numbers and digits. |
| var CDATA = '[CDATA[' |
| var DOCTYPE = 'DOCTYPE' |
| var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace' |
| var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/' |
| var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE } |
| |
| // http://www.w3.org/TR/REC-xml/#NT-NameStartChar |
| // This implementation works on strings, a single character at a time |
| // as such, it cannot ever support astral-plane characters (10000-EFFFF) |
| // without a significant breaking change to either this parser, or the |
| // JavaScript language. Implementation of an emoji-capable xml parser |
| // is left as an exercise for the reader. |
| var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ |
| |
| var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ |
| |
| var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ |
| var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/ |
| |
| function isWhitespace (c) { |
| return c === ' ' || c === '\n' || c === '\r' || c === '\t' |
| } |
| |
| function isQuote (c) { |
| return c === '"' || c === '\'' |
| } |
| |
| function isAttribEnd (c) { |
| return c === '>' || isWhitespace(c) |
| } |
| |
| function isMatch (regex, c) { |
| return regex.test(c) |
| } |
| |
| function notMatch (regex, c) { |
| return !isMatch(regex, c) |
| } |
| |
| var S = 0 |
| sax.STATE = { |
| BEGIN: S++, // leading byte order mark or whitespace |
| BEGIN_WHITESPACE: S++, // leading whitespace |
| TEXT: S++, // general stuff |
| TEXT_ENTITY: S++, // & and such. |
| OPEN_WAKA: S++, // < |
| SGML_DECL: S++, // <!BLARG |
| SGML_DECL_QUOTED: S++, // <!BLARG foo "bar |
| DOCTYPE: S++, // <!DOCTYPE |
| DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah |
| DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ... |
| DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo |
| COMMENT_STARTING: S++, // <!- |
| COMMENT: S++, // <!-- |
| COMMENT_ENDING: S++, // <!-- blah - |
| COMMENT_ENDED: S++, // <!-- blah -- |
| CDATA: S++, // <![CDATA[ something |
| CDATA_ENDING: S++, // ] |
| CDATA_ENDING_2: S++, // ]] |
| PROC_INST: S++, // <?hi |
| PROC_INST_BODY: S++, // <?hi there |
| PROC_INST_ENDING: S++, // <?hi "there" ? |
| OPEN_TAG: S++, // <strong |
| OPEN_TAG_SLASH: S++, // <strong / |
| ATTRIB: S++, // <a |
| ATTRIB_NAME: S++, // <a foo |
| ATTRIB_NAME_SAW_WHITE: S++, // <a foo _ |
| ATTRIB_VALUE: S++, // <a foo= |
| ATTRIB_VALUE_QUOTED: S++, // <a foo="bar |
| ATTRIB_VALUE_CLOSED: S++, // <a foo="bar" |
| ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar |
| ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar=""" |
| ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=" |
| CLOSE_TAG: S++, // </a |
| CLOSE_TAG_SAW_WHITE: S++, // </a > |
| SCRIPT: S++, // <script> ... |
| SCRIPT_ENDING: S++ // <script> ... < |
| } |
| |
| sax.XML_ENTITIES = { |
| 'amp': '&', |
| 'gt': '>', |
| 'lt': '<', |
| 'quot': '"', |
| 'apos': "'" |
| } |
| |
| sax.ENTITIES = { |
| 'amp': '&', |
| 'gt': '>', |
| 'lt': '<', |
| 'quot': '"', |
| 'apos': "'", |
| 'AElig': 198, |
| 'Aacute': 193, |
| 'Acirc': 194, |
| 'Agrave': 192, |
| 'Aring': 197, |
| 'Atilde': 195, |
| 'Auml': 196, |
| 'Ccedil': 199, |
| 'ETH': 208, |
| 'Eacute': 201, |
| 'Ecirc': 202, |
| 'Egrave': 200, |
| 'Euml': 203, |
| 'Iacute': 205, |
| 'Icirc': 206, |
| 'Igrave': 204, |
| 'Iuml': 207, |
| 'Ntilde': 209, |
| 'Oacute': 211, |
| 'Ocirc': 212, |
| 'Ograve': 210, |
| 'Oslash': 216, |
| 'Otilde': 213, |
| 'Ouml': 214, |
| 'THORN': 222, |
| 'Uacute': 218, |
| 'Ucirc': 219, |
| 'Ugrave': 217, |
| 'Uuml': 220, |
| 'Yacute': 221, |
| 'aacute': 225, |
| 'acirc': 226, |
| 'aelig': 230, |
| 'agrave': 224, |
| 'aring': 229, |
| 'atilde': 227, |
| 'auml': 228, |
| 'ccedil': 231, |
| 'eacute': 233, |
| 'ecirc': 234, |
| 'egrave': 232, |
| 'eth': 240, |
| 'euml': 235, |
| 'iacute': 237, |
| 'icirc': 238, |
| 'igrave': 236, |
| 'iuml': 239, |
| 'ntilde': 241, |
| 'oacute': 243, |
| 'ocirc': 244, |
| 'ograve': 242, |
| 'oslash': 248, |
| 'otilde': 245, |
| 'ouml': 246, |
| 'szlig': 223, |
| 'thorn': 254, |
| 'uacute': 250, |
| 'ucirc': 251, |
| 'ugrave': 249, |
| 'uuml': 252, |
| 'yacute': 253, |
| 'yuml': 255, |
| 'copy': 169, |
| 'reg': 174, |
| 'nbsp': 160, |
| 'iexcl': 161, |
| 'cent': 162, |
| 'pound': 163, |
| 'curren': 164, |
| 'yen': 165, |
| 'brvbar': 166, |
| 'sect': 167, |
| 'uml': 168, |
| 'ordf': 170, |
| 'laquo': 171, |
| 'not': 172, |
| 'shy': 173, |
| 'macr': 175, |
| 'deg': 176, |
| 'plusmn': 177, |
| 'sup1': 185, |
| 'sup2': 178, |
| 'sup3': 179, |
| 'acute': 180, |
| 'micro': 181, |
| 'para': 182, |
| 'middot': 183, |
| 'cedil': 184, |
| 'ordm': 186, |
| 'raquo': 187, |
| 'frac14': 188, |
| 'frac12': 189, |
| 'frac34': 190, |
| 'iquest': 191, |
| 'times': 215, |
| 'divide': 247, |
| 'OElig': 338, |
| 'oelig': 339, |
| 'Scaron': 352, |
| 'scaron': 353, |
| 'Yuml': 376, |
| 'fnof': 402, |
| 'circ': 710, |
| 'tilde': 732, |
| 'Alpha': 913, |
| 'Beta': 914, |
| 'Gamma': 915, |
| 'Delta': 916, |
| 'Epsilon': 917, |
| 'Zeta': 918, |
| 'Eta': 919, |
| 'Theta': 920, |
| 'Iota': 921, |
| 'Kappa': 922, |
| 'Lambda': 923, |
| 'Mu': 924, |
| 'Nu': 925, |
| 'Xi': 926, |
| 'Omicron': 927, |
| 'Pi': 928, |
| 'Rho': 929, |
| 'Sigma': 931, |
| 'Tau': 932, |
| 'Upsilon': 933, |
| 'Phi': 934, |
| 'Chi': 935, |
| 'Psi': 936, |
| 'Omega': 937, |
| 'alpha': 945, |
| 'beta': 946, |
| 'gamma': 947, |
| 'delta': 948, |
| 'epsilon': 949, |
| 'zeta': 950, |
| 'eta': 951, |
| 'theta': 952, |
| 'iota': 953, |
| 'kappa': 954, |
| 'lambda': 955, |
| 'mu': 956, |
| 'nu': 957, |
| 'xi': 958, |
| 'omicron': 959, |
| 'pi': 960, |
| 'rho': 961, |
| 'sigmaf': 962, |
| 'sigma': 963, |
| 'tau': 964, |
| 'upsilon': 965, |
| 'phi': 966, |
| 'chi': 967, |
| 'psi': 968, |
| 'omega': 969, |
| 'thetasym': 977, |
| 'upsih': 978, |
| 'piv': 982, |
| 'ensp': 8194, |
| 'emsp': 8195, |
| 'thinsp': 8201, |
| 'zwnj': 8204, |
| 'zwj': 8205, |
| 'lrm': 8206, |
| 'rlm': 8207, |
| 'ndash': 8211, |
| 'mdash': 8212, |
| 'lsquo': 8216, |
| 'rsquo': 8217, |
| 'sbquo': 8218, |
| 'ldquo': 8220, |
| 'rdquo': 8221, |
| 'bdquo': 8222, |
| 'dagger': 8224, |
| 'Dagger': 8225, |
| 'bull': 8226, |
| 'hellip': 8230, |
| 'permil': 8240, |
| 'prime': 8242, |
| 'Prime': 8243, |
| 'lsaquo': 8249, |
| 'rsaquo': 8250, |
| 'oline': 8254, |
| 'frasl': 8260, |
| 'euro': 8364, |
| 'image': 8465, |
| 'weierp': 8472, |
| 'real': 8476, |
| 'trade': 8482, |
| 'alefsym': 8501, |
| 'larr': 8592, |
| 'uarr': 8593, |
| 'rarr': 8594, |
| 'darr': 8595, |
| 'harr': 8596, |
| 'crarr': 8629, |
| 'lArr': 8656, |
| 'uArr': 8657, |
| 'rArr': 8658, |
| 'dArr': 8659, |
| 'hArr': 8660, |
| 'forall': 8704, |
| 'part': 8706, |
| 'exist': 8707, |
| 'empty': 8709, |
| 'nabla': 8711, |
| 'isin': 8712, |
| 'notin': 8713, |
| 'ni': 8715, |
| 'prod': 8719, |
| 'sum': 8721, |
| 'minus': 8722, |
| 'lowast': 8727, |
| 'radic': 8730, |
| 'prop': 8733, |
| 'infin': 8734, |
| 'ang': 8736, |
| 'and': 8743, |
| 'or': 8744, |
| 'cap': 8745, |
| 'cup': 8746, |
| 'int': 8747, |
| 'there4': 8756, |
| 'sim': 8764, |
| 'cong': 8773, |
| 'asymp': 8776, |
| 'ne': 8800, |
| 'equiv': 8801, |
| 'le': 8804, |
| 'ge': 8805, |
| 'sub': 8834, |
| 'sup': 8835, |
| 'nsub': 8836, |
| 'sube': 8838, |
| 'supe': 8839, |
| 'oplus': 8853, |
| 'otimes': 8855, |
| 'perp': 8869, |
| 'sdot': 8901, |
| 'lceil': 8968, |
| 'rceil': 8969, |
| 'lfloor': 8970, |
| 'rfloor': 8971, |
| 'lang': 9001, |
| 'rang': 9002, |
| 'loz': 9674, |
| 'spades': 9824, |
| 'clubs': 9827, |
| 'hearts': 9829, |
| 'diams': 9830 |
| } |
| |
| Object.keys(sax.ENTITIES).forEach(function (key) { |
| var e = sax.ENTITIES[key] |
| var s = typeof e === 'number' ? String.fromCharCode(e) : e |
| sax.ENTITIES[key] = s |
| }) |
| |
| for (var s in sax.STATE) { |
| sax.STATE[sax.STATE[s]] = s |
| } |
| |
| // shorthand |
| S = sax.STATE |
| |
| function emit (parser, event, data) { |
| parser[event] && parser[event](data) |
| } |
| |
| function emitNode (parser, nodeType, data) { |
| if (parser.textNode) closeText(parser) |
| emit(parser, nodeType, data) |
| } |
| |
| function closeText (parser) { |
| parser.textNode = textopts(parser.opt, parser.textNode) |
| if (parser.textNode) emit(parser, 'ontext', parser.textNode) |
| parser.textNode = '' |
| } |
| |
| function textopts (opt, text) { |
| if (opt.trim) text = text.trim() |
| if (opt.normalize) text = text.replace(/\s+/g, ' ') |
| return text |
| } |
| |
| function error (parser, er) { |
| closeText(parser) |
| if (parser.trackPosition) { |
| er += '\nLine: ' + parser.line + |
| '\nColumn: ' + parser.column + |
| '\nChar: ' + parser.c |
| } |
| er = new Error(er) |
| parser.error = er |
| emit(parser, 'onerror', er) |
| return parser |
| } |
| |
| function end (parser) { |
| if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag') |
| if ((parser.state !== S.BEGIN) && |
| (parser.state !== S.BEGIN_WHITESPACE) && |
| (parser.state !== S.TEXT)) { |
| error(parser, 'Unexpected end') |
| } |
| closeText(parser) |
| parser.c = '' |
| parser.closed = true |
| emit(parser, 'onend') |
| SAXParser.call(parser, parser.strict, parser.opt) |
| return parser |
| } |
| |
| function strictFail (parser, message) { |
| if (typeof parser !== 'object' || !(parser instanceof SAXParser)) { |
| throw new Error('bad call to strictFail') |
| } |
| if (parser.strict) { |
| error(parser, message) |
| } |
| } |
| |
| function newTag (parser) { |
| if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]() |
| var parent = parser.tags[parser.tags.length - 1] || parser |
| var tag = parser.tag = { name: parser.tagName, attributes: {} } |
| |
| // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar" |
| if (parser.opt.xmlns) { |
| tag.ns = parent.ns |
| } |
| parser.attribList.length = 0 |
| emitNode(parser, 'onopentagstart', tag) |
| } |
| |
| function qname (name, attribute) { |
| var i = name.indexOf(':') |
| var qualName = i < 0 ? [ '', name ] : name.split(':') |
| var prefix = qualName[0] |
| var local = qualName[1] |
| |
| // <x "xmlns"="http://foo"> |
| if (attribute && name === 'xmlns') { |
| prefix = 'xmlns' |
| local = '' |
| } |
| |
| return { prefix: prefix, local: local } |
| } |
| |
| function attrib (parser) { |
| if (!parser.strict) { |
| parser.attribName = parser.attribName[parser.looseCase]() |
| } |
| |
| if (parser.attribList.indexOf(parser.attribName) !== -1 || |
| parser.tag.attributes.hasOwnProperty(parser.attribName)) { |
| parser.attribName = parser.attribValue = '' |
| return |
| } |
| |
| if (parser.opt.xmlns) { |
| var qn = qname(parser.attribName, true) |
| var prefix = qn.prefix |
| var local = qn.local |
| |
| if (prefix === 'xmlns') { |
| // namespace binding attribute. push the binding into scope |
| if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) { |
| strictFail(parser, |
| 'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' + |
| 'Actual: ' + parser.attribValue) |
| } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) { |
| strictFail(parser, |
| 'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' + |
| 'Actual: ' + parser.attribValue) |
| } else { |
| var tag = parser.tag |
| var parent = parser.tags[parser.tags.length - 1] || parser |
| if (tag.ns === parent.ns) { |
| tag.ns = Object.create(parent.ns) |
| } |
| tag.ns[local] = parser.attribValue |
| } |
| } |
| |
| // defer onattribute events until all attributes have been seen |
| // so any new bindings can take effect. preserve attribute order |
| // so deferred events can be emitted in document order |
| parser.attribList.push([parser.attribName, parser.attribValue]) |
| } else { |
| // in non-xmlns mode, we can emit the event right away |
| parser.tag.attributes[parser.attribName] = parser.attribValue |
| emitNode(parser, 'onattribute', { |
| name: parser.attribName, |
| value: parser.attribValue |
| }) |
| } |
| |
| parser.attribName = parser.attribValue = '' |
| } |
| |
| function openTag (parser, selfClosing) { |
| if (parser.opt.xmlns) { |
| // emit namespace binding events |
| var tag = parser.tag |
| |
| // add namespace info to tag |
| var qn = qname(parser.tagName) |
| tag.prefix = qn.prefix |
| tag.local = qn.local |
| tag.uri = tag.ns[qn.prefix] || '' |
| |
| if (tag.prefix && !tag.uri) { |
| strictFail(parser, 'Unbound namespace prefix: ' + |
| JSON.stringify(parser.tagName)) |
| tag.uri = qn.prefix |
| } |
| |
| var parent = parser.tags[parser.tags.length - 1] || parser |
| if (tag.ns && parent.ns !== tag.ns) { |
| Object.keys(tag.ns).forEach(function (p) { |
| emitNode(parser, 'onopennamespace', { |
| prefix: p, |
| uri: tag.ns[p] |
| }) |
| }) |
| } |
| |
| // handle deferred onattribute events |
| // Note: do not apply default ns to attributes: |
| // http://www.w3.org/TR/REC-xml-names/#defaulting |
| for (var i = 0, l = parser.attribList.length; i < l; i++) { |
| var nv = parser.attribList[i] |
| var name = nv[0] |
| var value = nv[1] |
| var qualName = qname(name, true) |
| var prefix = qualName.prefix |
| var local = qualName.local |
| var uri = prefix === '' ? '' : (tag.ns[prefix] || '') |
| var a = { |
| name: name, |
| value: value, |
| prefix: prefix, |
| local: local, |
| uri: uri |
| } |
| |
| // if there's any attributes with an undefined namespace, |
| // then fail on them now. |
| if (prefix && prefix !== 'xmlns' && !uri) { |
| strictFail(parser, 'Unbound namespace prefix: ' + |
| JSON.stringify(prefix)) |
| a.uri = prefix |
| } |
| parser.tag.attributes[name] = a |
| emitNode(parser, 'onattribute', a) |
| } |
| parser.attribList.length = 0 |
| } |
| |
| parser.tag.isSelfClosing = !!selfClosing |
| |
| // process the tag |
| parser.sawRoot = true |
| parser.tags.push(parser.tag) |
| emitNode(parser, 'onopentag', parser.tag) |
| if (!selfClosing) { |
| // special case for <script> in non-strict mode. |
| if (!parser.noscript && parser.tagName.toLowerCase() === 'script') { |
| parser.state = S.SCRIPT |
| } else { |
| parser.state = S.TEXT |
| } |
| parser.tag = null |
| parser.tagName = '' |
| } |
| parser.attribName = parser.attribValue = '' |
| parser.attribList.length = 0 |
| } |
| |
| function closeTag (parser) { |
| if (!parser.tagName) { |
| strictFail(parser, 'Weird empty close tag.') |
| parser.textNode += '</>' |
| parser.state = S.TEXT |
| return |
| } |
| |
| if (parser.script) { |
| if (parser.tagName !== 'script') { |
| parser.script += '</' + parser.tagName + '>' |
| parser.tagName = '' |
| parser.state = S.SCRIPT |
| return |
| } |
| emitNode(parser, 'onscript', parser.script) |
| parser.script = '' |
| } |
| |
| // first make sure that the closing tag actually exists. |
| // <a><b></c></b></a> will close everything, otherwise. |
| var t = parser.tags.length |
| var tagName = parser.tagName |
| if (!parser.strict) { |
| tagName = tagName[parser.looseCase]() |
| } |
| var closeTo = tagName |
| while (t--) { |
| var close = parser.tags[t] |
| if (close.name !== closeTo) { |
| // fail the first time in strict mode |
| strictFail(parser, 'Unexpected close tag') |
| } else { |
| break |
| } |
| } |
| |
| // didn't find it. we already failed for strict, so just abort. |
| if (t < 0) { |
| strictFail(parser, 'Unmatched closing tag: ' + parser.tagName) |
| parser.textNode += '</' + parser.tagName + '>' |
| parser.state = S.TEXT |
| return |
| } |
| parser.tagName = tagName |
| var s = parser.tags.length |
| while (s-- > t) { |
| var tag = parser.tag = parser.tags.pop() |
| parser.tagName = parser.tag.name |
| emitNode(parser, 'onclosetag', parser.tagName) |
| |
| var x = {} |
| for (var i in tag.ns) { |
| x[i] = tag.ns[i] |
| } |
| |
| var parent = parser.tags[parser.tags.length - 1] || parser |
| if (parser.opt.xmlns && tag.ns !== parent.ns) { |
| // remove namespace bindings introduced by tag |
| Object.keys(tag.ns).forEach(function (p) { |
| var n = tag.ns[p] |
| emitNode(parser, 'onclosenamespace', { prefix: p, uri: n }) |
| }) |
| } |
| } |
| if (t === 0) parser.closedRoot = true |
| parser.tagName = parser.attribValue = parser.attribName = '' |
| parser.attribList.length = 0 |
| parser.state = S.TEXT |
| } |
| |
| function parseEntity (parser) { |
| var entity = parser.entity |
| var entityLC = entity.toLowerCase() |
| var num |
| var numStr = '' |
| |
| if (parser.ENTITIES[entity]) { |
| return parser.ENTITIES[entity] |
| } |
| if (parser.ENTITIES[entityLC]) { |
| return parser.ENTITIES[entityLC] |
| } |
| entity = entityLC |
| if (entity.charAt(0) === '#') { |
| if (entity.charAt(1) === 'x') { |
| entity = entity.slice(2) |
| num = parseInt(entity, 16) |
| numStr = num.toString(16) |
| } else { |
| entity = entity.slice(1) |
| num = parseInt(entity, 10) |
| numStr = num.toString(10) |
| } |
| } |
| entity = entity.replace(/^0+/, '') |
| if (isNaN(num) || numStr.toLowerCase() !== entity) { |
| strictFail(parser, 'Invalid character entity') |
| return '&' + parser.entity + ';' |
| } |
| |
| return String.fromCodePoint(num) |
| } |
| |
| function beginWhiteSpace (parser, c) { |
| if (c === '<') { |
| parser.state = S.OPEN_WAKA |
| parser.startTagPosition = parser.position |
| } else if (!isWhitespace(c)) { |
| // have to process this as a text node. |
| // weird, but happens. |
| strictFail(parser, 'Non-whitespace before first tag.') |
| parser.textNode = c |
| parser.state = S.TEXT |
| } |
| } |
| |
| function charAt (chunk, i) { |
| var result = '' |
| if (i < chunk.length) { |
| result = chunk.charAt(i) |
| } |
| return result |
| } |
| |
| function write (chunk) { |
| var parser = this |
| if (this.error) { |
| throw this.error |
| } |
| if (parser.closed) { |
| return error(parser, |
| 'Cannot write after close. Assign an onready handler.') |
| } |
| if (chunk === null) { |
| return end(parser) |
| } |
| if (typeof chunk === 'object') { |
| chunk = chunk.toString() |
| } |
| var i = 0 |
| var c = '' |
| while (true) { |
| c = charAt(chunk, i++) |
| parser.c = c |
| |
| if (!c) { |
| break |
| } |
| |
| if (parser.trackPosition) { |
| parser.position++ |
| if (c === '\n') { |
| parser.line++ |
| parser.column = 0 |
| } else { |
| parser.column++ |
| } |
| } |
| |
| switch (parser.state) { |
| case S.BEGIN: |
| parser.state = S.BEGIN_WHITESPACE |
| if (c === '\uFEFF') { |
| continue |
| } |
| beginWhiteSpace(parser, c) |
| continue |
| |
| case S.BEGIN_WHITESPACE: |
| beginWhiteSpace(parser, c) |
| continue |
| |
| case S.TEXT: |
| if (parser.sawRoot && !parser.closedRoot) { |
| var starti = i - 1 |
| while (c && c !== '<' && c !== '&') { |
| c = charAt(chunk, i++) |
| if (c && parser.trackPosition) { |
| parser.position++ |
| if (c === '\n') { |
| parser.line++ |
| parser.column = 0 |
| } else { |
| parser.column++ |
| } |
| } |
| } |
| parser.textNode += chunk.substring(starti, i - 1) |
| } |
| if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) { |
| parser.state = S.OPEN_WAKA |
| parser.startTagPosition = parser.position |
| } else { |
| if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) { |
| strictFail(parser, 'Text data outside of root node.') |
| } |
| if (c === '&') { |
| parser.state = S.TEXT_ENTITY |
| } else { |
| parser.textNode += c |
| } |
| } |
| continue |
| |
| case S.SCRIPT: |
| // only non-strict |
| if (c === '<') { |
| parser.state = S.SCRIPT_ENDING |
| } else { |
| parser.script += c |
| } |
| continue |
| |
| case S.SCRIPT_ENDING: |
| if (c === '/') { |
| parser.state = S.CLOSE_TAG |
| } else { |
| parser.script += '<' + c |
| parser.state = S.SCRIPT |
| } |
| continue |
| |
| case S.OPEN_WAKA: |
| // either a /, ?, !, or text is coming next. |
| if (c === '!') { |
| parser.state = S.SGML_DECL |
| parser.sgmlDecl = '' |
| } else if (isWhitespace(c)) { |
| // wait for it... |
| } else if (isMatch(nameStart, c)) { |
| parser.state = S.OPEN_TAG |
| parser.tagName = c |
| } else if (c === '/') { |
| parser.state = S.CLOSE_TAG |
| parser.tagName = '' |
| } else if (c === '?') { |
| parser.state = S.PROC_INST |
| parser.procInstName = parser.procInstBody = '' |
| } else { |
| strictFail(parser, 'Unencoded <') |
| // if there was some whitespace, then add that in. |
| if (parser.startTagPosition + 1 < parser.position) { |
| var pad = parser.position - parser.startTagPosition |
| c = new Array(pad).join(' ') + c |
| } |
| parser.textNode += '<' + c |
| parser.state = S.TEXT |
| } |
| continue |
| |
| case S.SGML_DECL: |
| if ((parser.sgmlDecl + c).toUpperCase() === CDATA) { |
| emitNode(parser, 'onopencdata') |
| parser.state = S.CDATA |
| parser.sgmlDecl = '' |
| parser.cdata = '' |
| } else if (parser.sgmlDecl + c === '--') { |
| parser.state = S.COMMENT |
| parser.comment = '' |
| parser.sgmlDecl = '' |
| } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) { |
| parser.state = S.DOCTYPE |
| if (parser.doctype || parser.sawRoot) { |
| strictFail(parser, |
| 'Inappropriately located doctype declaration') |
| } |
| parser.doctype = '' |
| parser.sgmlDecl = '' |
| } else if (c === '>') { |
| emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl) |
| parser.sgmlDecl = '' |
| parser.state = S.TEXT |
| } else if (isQuote(c)) { |
| parser.state = S.SGML_DECL_QUOTED |
| parser.sgmlDecl += c |
| } else { |
| parser.sgmlDecl += c |
| } |
| continue |
| |
| case S.SGML_DECL_QUOTED: |
| if (c === parser.q) { |
| parser.state = S.SGML_DECL |
| parser.q = '' |
| } |
| parser.sgmlDecl += c |
| continue |
| |
| case S.DOCTYPE: |
| if (c === '>') { |
| parser.state = S.TEXT |
| emitNode(parser, 'ondoctype', parser.doctype) |
| parser.doctype = true // just remember that we saw it. |
| } else { |
| parser.doctype += c |
| if (c === '[') { |
| parser.state = S.DOCTYPE_DTD |
| } else if (isQuote(c)) { |
| parser.state = S.DOCTYPE_QUOTED |
| parser.q = c |
| } |
| } |
| continue |
| |
| case S.DOCTYPE_QUOTED: |
| parser.doctype += c |
| if (c === parser.q) { |
| parser.q = '' |
| parser.state = S.DOCTYPE |
| } |
| continue |
| |
| case S.DOCTYPE_DTD: |
| parser.doctype += c |
| if (c === ']') { |
| parser.state = S.DOCTYPE |
| } else if (isQuote(c)) { |
| parser.state = S.DOCTYPE_DTD_QUOTED |
| parser.q = c |
| } |
| continue |
| |
| case S.DOCTYPE_DTD_QUOTED: |
| parser.doctype += c |
| if (c === parser.q) { |
| parser.state = S.DOCTYPE_DTD |
| parser.q = '' |
| } |
| continue |
| |
| case S.COMMENT: |
| if (c === '-') { |
| parser.state = S.COMMENT_ENDING |
| } else { |
| parser.comment += c |
| } |
| continue |
| |
| case S.COMMENT_ENDING: |
| if (c === '-') { |
| parser.state = S.COMMENT_ENDED |
| parser.comment = textopts(parser.opt, parser.comment) |
| if (parser.comment) { |
| emitNode(parser, 'oncomment', parser.comment) |
| } |
| parser.comment = '' |
| } else { |
| parser.comment += '-' + c |
| parser.state = S.COMMENT |
| } |
| continue |
| |
| case S.COMMENT_ENDED: |
| if (c !== '>') { |
| strictFail(parser, 'Malformed comment') |
| // allow <!-- blah -- bloo --> in non-strict mode, |
| // which is a comment of " blah -- bloo " |
| parser.comment += '--' + c |
| parser.state = S.COMMENT |
| } else { |
| parser.state = S.TEXT |
| } |
| continue |
| |
| case S.CDATA: |
| if (c === ']') { |
| parser.state = S.CDATA_ENDING |
| } else { |
| parser.cdata += c |
| } |
| continue |
| |
| case S.CDATA_ENDING: |
| if (c === ']') { |
| parser.state = S.CDATA_ENDING_2 |
| } else { |
| parser.cdata += ']' + c |
| parser.state = S.CDATA |
| } |
| continue |
| |
| case S.CDATA_ENDING_2: |
| if (c === '>') { |
| if (parser.cdata) { |
| emitNode(parser, 'oncdata', parser.cdata) |
| } |
| emitNode(parser, 'onclosecdata') |
| parser.cdata = '' |
| parser.state = S.TEXT |
| } else if (c === ']') { |
| parser.cdata += ']' |
| } else { |
| parser.cdata += ']]' + c |
| parser.state = S.CDATA |
| } |
| continue |
| |
| case S.PROC_INST: |
| if (c === '?') { |
| parser.state = S.PROC_INST_ENDING |
| } else if (isWhitespace(c)) { |
| parser.state = S.PROC_INST_BODY |
| } else { |
| parser.procInstName += c |
| } |
| continue |
| |
| case S.PROC_INST_BODY: |
| if (!parser.procInstBody && isWhitespace(c)) { |
| continue |
| } else if (c === '?') { |
| parser.state = S.PROC_INST_ENDING |
| } else { |
| parser.procInstBody += c |
| } |
| continue |
| |
| case S.PROC_INST_ENDING: |
| if (c === '>') { |
| emitNode(parser, 'onprocessinginstruction', { |
| name: parser.procInstName, |
| body: parser.procInstBody |
| }) |
| parser.procInstName = parser.procInstBody = '' |
| parser.state = S.TEXT |
| } else { |
| parser.procInstBody += '?' + c |
| parser.state = S.PROC_INST_BODY |
| } |
| continue |
| |
| case S.OPEN_TAG: |
| if (isMatch(nameBody, c)) { |
| parser.tagName += c |
| } else { |
| newTag(parser) |
| if (c === '>') { |
| openTag(parser) |
| } else if (c === '/') { |
| parser.state = S.OPEN_TAG_SLASH |
| } else { |
| if (!isWhitespace(c)) { |
| strictFail(parser, 'Invalid character in tag name') |
| } |
| parser.state = S.ATTRIB |
| } |
| } |
| continue |
| |
| case S.OPEN_TAG_SLASH: |
| if (c === '>') { |
| openTag(parser, true) |
| closeTag(parser) |
| } else { |
| strictFail(parser, 'Forward-slash in opening tag not followed by >') |
| parser.state = S.ATTRIB |
| } |
| continue |
| |
| case S.ATTRIB: |
| // haven't read the attribute name yet. |
| if (isWhitespace(c)) { |
| continue |
| } else if (c === '>') { |
| openTag(parser) |
| } else if (c === '/') { |
| parser.state = S.OPEN_TAG_SLASH |
| } else if (isMatch(nameStart, c)) { |
| parser.attribName = c |
| parser.attribValue = '' |
| parser.state = S.ATTRIB_NAME |
| } else { |
| strictFail(parser, 'Invalid attribute name') |
| } |
| continue |
| |
| case S.ATTRIB_NAME: |
| if (c === '=') { |
| parser.state = S.ATTRIB_VALUE |
| } else if (c === '>') { |
| strictFail(parser, 'Attribute without value') |
| parser.attribValue = parser.attribName |
| attrib(parser) |
| openTag(parser) |
| } else if (isWhitespace(c)) { |
| parser.state = S.ATTRIB_NAME_SAW_WHITE |
| } else if (isMatch(nameBody, c)) { |
| parser.attribName += c |
| } else { |
| strictFail(parser, 'Invalid attribute name') |
| } |
| continue |
| |
| case S.ATTRIB_NAME_SAW_WHITE: |
| if (c === '=') { |
| parser.state = S.ATTRIB_VALUE |
| } else if (isWhitespace(c)) { |
| continue |
| } else { |
| strictFail(parser, 'Attribute without value') |
| parser.tag.attributes[parser.attribName] = '' |
| parser.attribValue = '' |
| emitNode(parser, 'onattribute', { |
| name: parser.attribName, |
| value: '' |
| }) |
| parser.attribName = '' |
| if (c === '>') { |
| openTag(parser) |
| } else if (isMatch(nameStart, c)) { |
| parser.attribName = c |
| parser.state = S.ATTRIB_NAME |
| } else { |
| strictFail(parser, 'Invalid attribute name') |
| parser.state = S.ATTRIB |
| } |
| } |
| continue |
| |
| case S.ATTRIB_VALUE: |
| if (isWhitespace(c)) { |
| continue |
| } else if (isQuote(c)) { |
| parser.q = c |
| parser.state = S.ATTRIB_VALUE_QUOTED |
| } else { |
| strictFail(parser, 'Unquoted attribute value') |
| parser.state = S.ATTRIB_VALUE_UNQUOTED |
| parser.attribValue = c |
| } |
| continue |
| |
| case S.ATTRIB_VALUE_QUOTED: |
| if (c !== parser.q) { |
| if (c === '&') { |
| parser.state = S.ATTRIB_VALUE_ENTITY_Q |
| } else { |
| parser.attribValue += c |
| } |
| continue |
| } |
| attrib(parser) |
| parser.q = '' |
| parser.state = S.ATTRIB_VALUE_CLOSED |
| continue |
| |
| case S.ATTRIB_VALUE_CLOSED: |
| if (isWhitespace(c)) { |
| parser.state = S.ATTRIB |
| } else if (c === '>') { |
| openTag(parser) |
| } else if (c === '/') { |
| parser.state = S.OPEN_TAG_SLASH |
| } else if (isMatch(nameStart, c)) { |
| strictFail(parser, 'No whitespace between attributes') |
| parser.attribName = c |
| parser.attribValue = '' |
| parser.state = S.ATTRIB_NAME |
| } else { |
| strictFail(parser, 'Invalid attribute name') |
| } |
| continue |
| |
| case S.ATTRIB_VALUE_UNQUOTED: |
| if (!isAttribEnd(c)) { |
| if (c === '&') { |
| parser.state = S.ATTRIB_VALUE_ENTITY_U |
| } else { |
| parser.attribValue += c |
| } |
| continue |
| } |
| attrib(parser) |
| if (c === '>') { |
| openTag(parser) |
| } else { |
| parser.state = S.ATTRIB |
| } |
| continue |
| |
| case S.CLOSE_TAG: |
| if (!parser.tagName) { |
| if (isWhitespace(c)) { |
| continue |
| } else if (notMatch(nameStart, c)) { |
| if (parser.script) { |
| parser.script += '</' + c |
| parser.state = S.SCRIPT |
| } else { |
| strictFail(parser, 'Invalid tagname in closing tag.') |
| } |
| } else { |
| parser.tagName = c |
| } |
| } else if (c === '>') { |
| closeTag(parser) |
| } else if (isMatch(nameBody, c)) { |
| parser.tagName += c |
| } else if (parser.script) { |
| parser.script += '</' + parser.tagName |
| parser.tagName = '' |
| parser.state = S.SCRIPT |
| } else { |
| if (!isWhitespace(c)) { |
| strictFail(parser, 'Invalid tagname in closing tag') |
| } |
| parser.state = S.CLOSE_TAG_SAW_WHITE |
| } |
| continue |
| |
| case S.CLOSE_TAG_SAW_WHITE: |
| if (isWhitespace(c)) { |
| continue |
| } |
| if (c === '>') { |
| closeTag(parser) |
| } else { |
| strictFail(parser, 'Invalid characters in closing tag') |
| } |
| continue |
| |
| case S.TEXT_ENTITY: |
| case S.ATTRIB_VALUE_ENTITY_Q: |
| case S.ATTRIB_VALUE_ENTITY_U: |
| var returnState |
| var buffer |
| switch (parser.state) { |
| case S.TEXT_ENTITY: |
| returnState = S.TEXT |
| buffer = 'textNode' |
| break |
| |
| case S.ATTRIB_VALUE_ENTITY_Q: |
| returnState = S.ATTRIB_VALUE_QUOTED |
| buffer = 'attribValue' |
| break |
| |
| case S.ATTRIB_VALUE_ENTITY_U: |
| returnState = S.ATTRIB_VALUE_UNQUOTED |
| buffer = 'attribValue' |
| break |
| } |
| |
| if (c === ';') { |
| parser[buffer] += parseEntity(parser) |
| parser.entity = '' |
| parser.state = returnState |
| } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) { |
| parser.entity += c |
| } else { |
| strictFail(parser, 'Invalid character in entity name') |
| parser[buffer] += '&' + parser.entity + c |
| parser.entity = '' |
| parser.state = returnState |
| } |
| |
| continue |
| |
| default: |
| throw new Error(parser, 'Unknown state: ' + parser.state) |
| } |
| } // while |
| |
| if (parser.position >= parser.bufferCheckPosition) { |
| checkBufferLength(parser) |
| } |
| return parser |
| } |
| |
| /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ |
| /* istanbul ignore next */ |
| if (!String.fromCodePoint) { |
| (function () { |
| var stringFromCharCode = String.fromCharCode |
| var floor = Math.floor |
| var fromCodePoint = function () { |
| var MAX_SIZE = 0x4000 |
| var codeUnits = [] |
| var highSurrogate |
| var lowSurrogate |
| var index = -1 |
| var length = arguments.length |
| if (!length) { |
| return '' |
| } |
| var result = '' |
| while (++index < length) { |
| var codePoint = Number(arguments[index]) |
| if ( |
| !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` |
| codePoint < 0 || // not a valid Unicode code point |
| codePoint > 0x10FFFF || // not a valid Unicode code point |
| floor(codePoint) !== codePoint // not an integer |
| ) { |
| throw RangeError('Invalid code point: ' + codePoint) |
| } |
| if (codePoint <= 0xFFFF) { // BMP code point |
| codeUnits.push(codePoint) |
| } else { // Astral code point; split in surrogate halves |
| // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae |
| codePoint -= 0x10000 |
| highSurrogate = (codePoint >> 10) + 0xD800 |
| lowSurrogate = (codePoint % 0x400) + 0xDC00 |
| codeUnits.push(highSurrogate, lowSurrogate) |
| } |
| if (index + 1 === length || codeUnits.length > MAX_SIZE) { |
| result += stringFromCharCode.apply(null, codeUnits) |
| codeUnits.length = 0 |
| } |
| } |
| return result |
| } |
| /* istanbul ignore next */ |
| if (Object.defineProperty) { |
| Object.defineProperty(String, 'fromCodePoint', { |
| value: fromCodePoint, |
| configurable: true, |
| writable: true |
| }) |
| } else { |
| String.fromCodePoint = fromCodePoint |
| } |
| }()) |
| } |
| })( false ? 0 : exports) |
| |
| |
| /***/ }), |
| |
| /***/ 4294: |
| /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { |
| |
| module.exports = __nccwpck_require__(4219); |
| |
| |
| /***/ }), |
| |
| /***/ 4219: |
| /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { |
| |
| "use strict"; |
| |
| |
| var net = __nccwpck_require__(1631); |
| var tls = __nccwpck_require__(4016); |
| var http = __nccwpck_require__(8605); |
| var https = __nccwpck_require__(7211); |
| var events = __nccwpck_require__(8614); |
| var assert = __nccwpck_require__(2357); |
| var util = __nccwpck_require__(1669); |
| |
| |
| exports.httpOverHttp = httpOverHttp; |
| exports.httpsOverHttp = httpsOverHttp; |
| exports.httpOverHttps = httpOverHttps; |
| exports.httpsOverHttps = httpsOverHttps; |
| |
| |
| function httpOverHttp(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = http.request; |
| return agent; |
| } |
| |
| function httpsOverHttp(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = http.request; |
| agent.createSocket = createSecureSocket; |
| agent.defaultPort = 443; |
| return agent; |
| } |
| |
| function httpOverHttps(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = https.request; |
| return agent; |
| } |
| |
| function httpsOverHttps(options) { |
| var agent = new TunnelingAgent(options); |
| agent.request = https.request; |
| agent.createSocket = createSecureSocket; |
| agent.defaultPort = 443; |
| return agent; |
| } |
| |
| |
| function TunnelingAgent(options) { |
| var self = this; |
| self.options = options || {}; |
| self.proxyOptions = self.options.proxy || {}; |
| self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; |
| self.requests = []; |
| self.sockets = []; |
| |
| self.on('free', function onFree(socket, host, port, localAddress) { |
| var options = toOptions(host, port, localAddress); |
| for (var i = 0, len = self.requests.length; i < len; ++i) { |
| var pending = self.requests[i]; |
| if (pending.host === options.host && pending.port === options.port) { |
| // Detect the request to connect same origin server, |
| // reuse the connection. |
| self.requests.splice(i, 1); |
| pending.request.onSocket(socket); |
| return; |
| } |
| } |
| socket.destroy(); |
| self.removeSocket(socket); |
| }); |
| } |
| util.inherits(TunnelingAgent, events.EventEmitter); |
| |
| TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { |
| var self = this; |
| var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); |
| |
| if (self.sockets.length >= this.maxSockets) { |
| // We are over limit so we'll add it to the queue. |
| self.requests.push(options); |
| return; |
| } |
| |
| // If we are under maxSockets create a new one. |
| self.createSocket(options, function(socket) { |
| socket.on('free', onFree); |
| socket.on('close', onCloseOrRemove); |
| socket.on('agentRemove', onCloseOrRemove); |
| req.onSocket(socket); |
| |
| function onFree() { |
| self.emit('free', socket, options); |
| } |
| |
| function onCloseOrRemove(err) { |
| self.removeSocket(socket); |
| socket.removeListener('free', onFree); |
| socket.removeListener('close', onCloseOrRemove); |
| socket.removeListener('agentRemove', onCloseOrRemove); |
| } |
| }); |
| }; |
| |
| TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { |
| var self = this; |
| var placeholder = {}; |
| self.sockets.push(placeholder); |
| |
| var connectOptions = mergeOptions({}, self.proxyOptions, { |
| method: 'CONNECT', |
| path: options.host + ':' + options.port, |
| agent: false, |
| headers: { |
| host: options.host + ':' + options.port |
| } |
| }); |
| if (options.localAddress) { |
| connectOptions.localAddress = options.localAddress; |
| } |
| if (connectOptions.proxyAuth) { |
| connectOptions.headers = connectOptions.headers || {}; |
| connectOptions.headers['Proxy-Authorization'] = 'Basic ' + |
| new Buffer(connectOptions.proxyAuth).toString('base64'); |
| } |
| |
| debug('making CONNECT request'); |
| var connectReq = self.request(connectOptions); |
| connectReq.useChunkedEncodingByDefault = false; // for v0.6 |
| connectReq.once('response', onResponse); // for v0.6 |
| connectReq.once('upgrade', onUpgrade); // for v0.6 |
| connectReq.once('connect', onConnect); // for v0.7 or later |
| connectReq.once('error', onError); |
| connectReq.end(); |
| |
| function onResponse(res) { |
| // Very hacky. This is necessary to avoid http-parser leaks. |
| res.upgrade = true; |
| } |
| |
| function onUpgrade(res, socket, head) { |
| // Hacky. |
| process.nextTick(function() { |
| onConnect(res, socket, head); |
| }); |
| } |
| |
| function onConnect(res, socket, head) { |
| connectReq.removeAllListeners(); |
| socket.removeAllListeners(); |
| |
| if (res.statusCode !== 200) { |
| debug('tunneling socket could not be established, statusCode=%d', |
| res.statusCode); |
| socket.destroy(); |
| var error = new Error('tunneling socket could not be established, ' + |
| 'statusCode=' + res.statusCode); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| return; |
| } |
| if (head.length > 0) { |
| debug('got illegal response body from proxy'); |
| socket.destroy(); |
| var error = new Error('got illegal response body from proxy'); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| return; |
| } |
| debug('tunneling connection has established'); |
| self.sockets[self.sockets.indexOf(placeholder)] = socket; |
| return cb(socket); |
| } |
| |
| function onError(cause) { |
| connectReq.removeAllListeners(); |
| |
| debug('tunneling socket could not be established, cause=%s\n', |
| cause.message, cause.stack); |
| var error = new Error('tunneling socket could not be established, ' + |
| 'cause=' + cause.message); |
| error.code = 'ECONNRESET'; |
| options.request.emit('error', error); |
| self.removeSocket(placeholder); |
| } |
| }; |
| |
| TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { |
| var pos = this.sockets.indexOf(socket) |
| if (pos === -1) { |
| return; |
| } |
| this.sockets.splice(pos, 1); |
| |
| var pending = this.requests.shift(); |
| if (pending) { |
| // If we have pending requests and a socket gets closed a new one |
| // needs to be created to take over in the pool for the one that closed. |
| this.createSocket(pending, function(socket) { |
| pending.request.onSocket(socket); |
| }); |
| } |
| }; |
| |
| function createSecureSocket(options, cb) { |
| var self = this; |
| TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { |
| var hostHeader = options.request.getHeader('host'); |
| var tlsOptions = mergeOptions({}, self.options, { |
| socket: socket, |
| servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host |
| }); |
| |
| // 0 is dummy port for v0.6 |
| var secureSocket = tls.connect(0, tlsOptions); |
| self.sockets[self.sockets.indexOf(socket)] = secureSocket; |
| cb(secureSocket); |
| }); |
| } |
| |
| |
| function toOptions(host, port, localAddress) { |
| if (typeof host === 'string') { // since v0.10 |
| return { |
| host: host, |
| port: port, |
| localAddress: localAddress |
| }; |
| } |
| return host; // for v0.11 or later |
| } |
| |
| function mergeOptions(target) { |
| for (var i = 1, len = arguments.length; i < len; ++i) { |
| var overrides = arguments[i]; |
| if (typeof overrides === 'object') { |
| var keys = Object.keys(overrides); |
| for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { |
| var k = keys[j]; |
| if (overrides[k] !== undefined) { |
| target[k] = overrides[k]; |
| } |
| } |
| } |
| } |
| return target; |
| } |
| |
| |
| var debug; |
| if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { |
| debug = function() { |
| var args = Array.prototype.slice.call(arguments); |
| if (typeof args[0] === 'string') { |
| args[0] = 'TUNNEL: ' + args[0]; |
| } else { |
| args.unshift('TUNNEL:'); |
| } |
| console.error.apply(console, args); |
| } |
| } else { |
| debug = function() {}; |
| } |
| exports.debug = debug; // for test |
| |
| |
| /***/ }), |
| |
| /***/ 5030: |
| /***/ ((__unused_webpack_module, exports) => { |
| |
| "use strict"; |
| |
| |
| Object.defineProperty(exports, "__esModule", ({ value: true })); |
| |
| function getUserAgent() { |
| if (typeof navigator === "object" && "userAgent" in navigator) { |
| return navigator.userAgent; |
| } |
| |
| if (typeof process === "object" && "version" in process) { |
| return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; |
| } |
| |
| return "<environment undetectable>"; |
| } |
| |
| exports.getUserAgent = getUserAgent; |
| //# sourceMappingURL=index.js.map |
| |
| |
| /***/ }), |
| |
| /***/ 2940: |
| /***/ ((module) => { |
| |
| // Returns a wrapper function that returns a wrapped callback |
| // The wrapper function should do some stuff, and return a |
| // presumably different callback function. |
| // This makes sure that own properties are retained, so that |
| // decorations and such are not lost along the way. |
| module.exports = wrappy |
| function wrappy (fn, cb) { |
| if (fn && cb) return wrappy(fn)(cb) |
| |
| if (typeof fn !== 'function') |
| throw new TypeError('need wrapper function') |
| |
| Object.keys(fn).forEach(function (k) { |
| wrapper[k] = fn[k] |
| }) |
| |
| return wrapper |
| |
| function wrapper() { |
| var args = new Array(arguments.length) |
| for (var i = 0; i < args.length; i++) { |
| args[i] = arguments[i] |
| } |
| var ret = fn.apply(this, args) |
| var cb = args[args.length-1] |
| if (typeof ret === 'function' && ret !== cb) { |
| Object.keys(cb).forEach(function (k) { |
| ret[k] = cb[k] |
| }) |
| } |
| return ret |
| } |
| } |
| |
| |
| /***/ }), |
| |
| /***/ 2624: |
| /***/ (function(__unused_webpack_module, exports) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| "use strict"; |
| exports.stripBOM = function(str) { |
| if (str[0] === '\uFEFF') { |
| return str.substring(1); |
| } else { |
| return str; |
| } |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 3337: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| "use strict"; |
| var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA, |
| hasProp = {}.hasOwnProperty; |
| |
| builder = __nccwpck_require__(2958); |
| |
| defaults = __nccwpck_require__(7251).defaults; |
| |
| requiresCDATA = function(entry) { |
| return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0); |
| }; |
| |
| wrapCDATA = function(entry) { |
| return "<![CDATA[" + (escapeCDATA(entry)) + "]]>"; |
| }; |
| |
| escapeCDATA = function(entry) { |
| return entry.replace(']]>', ']]]]><![CDATA[>'); |
| }; |
| |
| exports.Builder = (function() { |
| function Builder(opts) { |
| var key, ref, value; |
| this.options = {}; |
| ref = defaults["0.2"]; |
| for (key in ref) { |
| if (!hasProp.call(ref, key)) continue; |
| value = ref[key]; |
| this.options[key] = value; |
| } |
| for (key in opts) { |
| if (!hasProp.call(opts, key)) continue; |
| value = opts[key]; |
| this.options[key] = value; |
| } |
| } |
| |
| Builder.prototype.buildObject = function(rootObj) { |
| var attrkey, charkey, render, rootElement, rootName; |
| attrkey = this.options.attrkey; |
| charkey = this.options.charkey; |
| if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) { |
| rootName = Object.keys(rootObj)[0]; |
| rootObj = rootObj[rootName]; |
| } else { |
| rootName = this.options.rootName; |
| } |
| render = (function(_this) { |
| return function(element, obj) { |
| var attr, child, entry, index, key, value; |
| if (typeof obj !== 'object') { |
| if (_this.options.cdata && requiresCDATA(obj)) { |
| element.raw(wrapCDATA(obj)); |
| } else { |
| element.txt(obj); |
| } |
| } else if (Array.isArray(obj)) { |
| for (index in obj) { |
| if (!hasProp.call(obj, index)) continue; |
| child = obj[index]; |
| for (key in child) { |
| entry = child[key]; |
| element = render(element.ele(key), entry).up(); |
| } |
| } |
| } else { |
| for (key in obj) { |
| if (!hasProp.call(obj, key)) continue; |
| child = obj[key]; |
| if (key === attrkey) { |
| if (typeof child === "object") { |
| for (attr in child) { |
| value = child[attr]; |
| element = element.att(attr, value); |
| } |
| } |
| } else if (key === charkey) { |
| if (_this.options.cdata && requiresCDATA(child)) { |
| element = element.raw(wrapCDATA(child)); |
| } else { |
| element = element.txt(child); |
| } |
| } else if (Array.isArray(child)) { |
| for (index in child) { |
| if (!hasProp.call(child, index)) continue; |
| entry = child[index]; |
| if (typeof entry === 'string') { |
| if (_this.options.cdata && requiresCDATA(entry)) { |
| element = element.ele(key).raw(wrapCDATA(entry)).up(); |
| } else { |
| element = element.ele(key, entry).up(); |
| } |
| } else { |
| element = render(element.ele(key), entry).up(); |
| } |
| } |
| } else if (typeof child === "object") { |
| element = render(element.ele(key), child).up(); |
| } else { |
| if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) { |
| element = element.ele(key).raw(wrapCDATA(child)).up(); |
| } else { |
| if (child == null) { |
| child = ''; |
| } |
| element = element.ele(key, child.toString()).up(); |
| } |
| } |
| } |
| } |
| return element; |
| }; |
| })(this); |
| rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, { |
| headless: this.options.headless, |
| allowSurrogateChars: this.options.allowSurrogateChars |
| }); |
| return render(rootElement, rootObj).end(this.options.renderOpts); |
| }; |
| |
| return Builder; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7251: |
| /***/ (function(__unused_webpack_module, exports) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| exports.defaults = { |
| "0.1": { |
| explicitCharkey: false, |
| trim: true, |
| normalize: true, |
| normalizeTags: false, |
| attrkey: "@", |
| charkey: "#", |
| explicitArray: false, |
| ignoreAttrs: false, |
| mergeAttrs: false, |
| explicitRoot: false, |
| validator: null, |
| xmlns: false, |
| explicitChildren: false, |
| childkey: '@@', |
| charsAsChildren: false, |
| includeWhiteChars: false, |
| async: false, |
| strict: true, |
| attrNameProcessors: null, |
| attrValueProcessors: null, |
| tagNameProcessors: null, |
| valueProcessors: null, |
| emptyTag: '' |
| }, |
| "0.2": { |
| explicitCharkey: false, |
| trim: false, |
| normalize: false, |
| normalizeTags: false, |
| attrkey: "$", |
| charkey: "_", |
| explicitArray: true, |
| ignoreAttrs: false, |
| mergeAttrs: false, |
| explicitRoot: true, |
| validator: null, |
| xmlns: false, |
| explicitChildren: false, |
| preserveChildrenOrder: false, |
| childkey: '$$', |
| charsAsChildren: false, |
| includeWhiteChars: false, |
| async: false, |
| strict: true, |
| attrNameProcessors: null, |
| attrValueProcessors: null, |
| tagNameProcessors: null, |
| valueProcessors: null, |
| rootName: 'root', |
| xmldec: { |
| 'version': '1.0', |
| 'encoding': 'UTF-8', |
| 'standalone': true |
| }, |
| doctype: null, |
| renderOpts: { |
| 'pretty': true, |
| 'indent': ' ', |
| 'newline': '\n' |
| }, |
| headless: false, |
| chunkSize: 10000, |
| emptyTag: '', |
| cdata: false |
| } |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 3314: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| "use strict"; |
| var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate, |
| bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| sax = __nccwpck_require__(2043); |
| |
| events = __nccwpck_require__(8614); |
| |
| bom = __nccwpck_require__(2624); |
| |
| processors = __nccwpck_require__(9236); |
| |
| setImmediate = __nccwpck_require__(8213).setImmediate; |
| |
| defaults = __nccwpck_require__(7251).defaults; |
| |
| isEmpty = function(thing) { |
| return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0; |
| }; |
| |
| processItem = function(processors, item, key) { |
| var i, len, process; |
| for (i = 0, len = processors.length; i < len; i++) { |
| process = processors[i]; |
| item = process(item, key); |
| } |
| return item; |
| }; |
| |
| exports.Parser = (function(superClass) { |
| extend(Parser, superClass); |
| |
| function Parser(opts) { |
| this.parseStringPromise = bind(this.parseStringPromise, this); |
| this.parseString = bind(this.parseString, this); |
| this.reset = bind(this.reset, this); |
| this.assignOrPush = bind(this.assignOrPush, this); |
| this.processAsync = bind(this.processAsync, this); |
| var key, ref, value; |
| if (!(this instanceof exports.Parser)) { |
| return new exports.Parser(opts); |
| } |
| this.options = {}; |
| ref = defaults["0.2"]; |
| for (key in ref) { |
| if (!hasProp.call(ref, key)) continue; |
| value = ref[key]; |
| this.options[key] = value; |
| } |
| for (key in opts) { |
| if (!hasProp.call(opts, key)) continue; |
| value = opts[key]; |
| this.options[key] = value; |
| } |
| if (this.options.xmlns) { |
| this.options.xmlnskey = this.options.attrkey + "ns"; |
| } |
| if (this.options.normalizeTags) { |
| if (!this.options.tagNameProcessors) { |
| this.options.tagNameProcessors = []; |
| } |
| this.options.tagNameProcessors.unshift(processors.normalize); |
| } |
| this.reset(); |
| } |
| |
| Parser.prototype.processAsync = function() { |
| var chunk, err; |
| try { |
| if (this.remaining.length <= this.options.chunkSize) { |
| chunk = this.remaining; |
| this.remaining = ''; |
| this.saxParser = this.saxParser.write(chunk); |
| return this.saxParser.close(); |
| } else { |
| chunk = this.remaining.substr(0, this.options.chunkSize); |
| this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length); |
| this.saxParser = this.saxParser.write(chunk); |
| return setImmediate(this.processAsync); |
| } |
| } catch (error1) { |
| err = error1; |
| if (!this.saxParser.errThrown) { |
| this.saxParser.errThrown = true; |
| return this.emit(err); |
| } |
| } |
| }; |
| |
| Parser.prototype.assignOrPush = function(obj, key, newValue) { |
| if (!(key in obj)) { |
| if (!this.options.explicitArray) { |
| return obj[key] = newValue; |
| } else { |
| return obj[key] = [newValue]; |
| } |
| } else { |
| if (!(obj[key] instanceof Array)) { |
| obj[key] = [obj[key]]; |
| } |
| return obj[key].push(newValue); |
| } |
| }; |
| |
| Parser.prototype.reset = function() { |
| var attrkey, charkey, ontext, stack; |
| this.removeAllListeners(); |
| this.saxParser = sax.parser(this.options.strict, { |
| trim: false, |
| normalize: false, |
| xmlns: this.options.xmlns |
| }); |
| this.saxParser.errThrown = false; |
| this.saxParser.onerror = (function(_this) { |
| return function(error) { |
| _this.saxParser.resume(); |
| if (!_this.saxParser.errThrown) { |
| _this.saxParser.errThrown = true; |
| return _this.emit("error", error); |
| } |
| }; |
| })(this); |
| this.saxParser.onend = (function(_this) { |
| return function() { |
| if (!_this.saxParser.ended) { |
| _this.saxParser.ended = true; |
| return _this.emit("end", _this.resultObject); |
| } |
| }; |
| })(this); |
| this.saxParser.ended = false; |
| this.EXPLICIT_CHARKEY = this.options.explicitCharkey; |
| this.resultObject = null; |
| stack = []; |
| attrkey = this.options.attrkey; |
| charkey = this.options.charkey; |
| this.saxParser.onopentag = (function(_this) { |
| return function(node) { |
| var key, newValue, obj, processedKey, ref; |
| obj = {}; |
| obj[charkey] = ""; |
| if (!_this.options.ignoreAttrs) { |
| ref = node.attributes; |
| for (key in ref) { |
| if (!hasProp.call(ref, key)) continue; |
| if (!(attrkey in obj) && !_this.options.mergeAttrs) { |
| obj[attrkey] = {}; |
| } |
| newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key]; |
| processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key; |
| if (_this.options.mergeAttrs) { |
| _this.assignOrPush(obj, processedKey, newValue); |
| } else { |
| obj[attrkey][processedKey] = newValue; |
| } |
| } |
| } |
| obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name; |
| if (_this.options.xmlns) { |
| obj[_this.options.xmlnskey] = { |
| uri: node.uri, |
| local: node.local |
| }; |
| } |
| return stack.push(obj); |
| }; |
| })(this); |
| this.saxParser.onclosetag = (function(_this) { |
| return function() { |
| var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath; |
| obj = stack.pop(); |
| nodeName = obj["#name"]; |
| if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) { |
| delete obj["#name"]; |
| } |
| if (obj.cdata === true) { |
| cdata = obj.cdata; |
| delete obj.cdata; |
| } |
| s = stack[stack.length - 1]; |
| if (obj[charkey].match(/^\s*$/) && !cdata) { |
| emptyStr = obj[charkey]; |
| delete obj[charkey]; |
| } else { |
| if (_this.options.trim) { |
| obj[charkey] = obj[charkey].trim(); |
| } |
| if (_this.options.normalize) { |
| obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim(); |
| } |
| obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey]; |
| if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) { |
| obj = obj[charkey]; |
| } |
| } |
| if (isEmpty(obj)) { |
| obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr; |
| } |
| if (_this.options.validator != null) { |
| xpath = "/" + ((function() { |
| var i, len, results; |
| results = []; |
| for (i = 0, len = stack.length; i < len; i++) { |
| node = stack[i]; |
| results.push(node["#name"]); |
| } |
| return results; |
| })()).concat(nodeName).join("/"); |
| (function() { |
| var err; |
| try { |
| return obj = _this.options.validator(xpath, s && s[nodeName], obj); |
| } catch (error1) { |
| err = error1; |
| return _this.emit("error", err); |
| } |
| })(); |
| } |
| if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') { |
| if (!_this.options.preserveChildrenOrder) { |
| node = {}; |
| if (_this.options.attrkey in obj) { |
| node[_this.options.attrkey] = obj[_this.options.attrkey]; |
| delete obj[_this.options.attrkey]; |
| } |
| if (!_this.options.charsAsChildren && _this.options.charkey in obj) { |
| node[_this.options.charkey] = obj[_this.options.charkey]; |
| delete obj[_this.options.charkey]; |
| } |
| if (Object.getOwnPropertyNames(obj).length > 0) { |
| node[_this.options.childkey] = obj; |
| } |
| obj = node; |
| } else if (s) { |
| s[_this.options.childkey] = s[_this.options.childkey] || []; |
| objClone = {}; |
| for (key in obj) { |
| if (!hasProp.call(obj, key)) continue; |
| objClone[key] = obj[key]; |
| } |
| s[_this.options.childkey].push(objClone); |
| delete obj["#name"]; |
| if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) { |
| obj = obj[charkey]; |
| } |
| } |
| } |
| if (stack.length > 0) { |
| return _this.assignOrPush(s, nodeName, obj); |
| } else { |
| if (_this.options.explicitRoot) { |
| old = obj; |
| obj = {}; |
| obj[nodeName] = old; |
| } |
| _this.resultObject = obj; |
| _this.saxParser.ended = true; |
| return _this.emit("end", _this.resultObject); |
| } |
| }; |
| })(this); |
| ontext = (function(_this) { |
| return function(text) { |
| var charChild, s; |
| s = stack[stack.length - 1]; |
| if (s) { |
| s[charkey] += text; |
| if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) { |
| s[_this.options.childkey] = s[_this.options.childkey] || []; |
| charChild = { |
| '#name': '__text__' |
| }; |
| charChild[charkey] = text; |
| if (_this.options.normalize) { |
| charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim(); |
| } |
| s[_this.options.childkey].push(charChild); |
| } |
| return s; |
| } |
| }; |
| })(this); |
| this.saxParser.ontext = ontext; |
| return this.saxParser.oncdata = (function(_this) { |
| return function(text) { |
| var s; |
| s = ontext(text); |
| if (s) { |
| return s.cdata = true; |
| } |
| }; |
| })(this); |
| }; |
| |
| Parser.prototype.parseString = function(str, cb) { |
| var err; |
| if ((cb != null) && typeof cb === "function") { |
| this.on("end", function(result) { |
| this.reset(); |
| return cb(null, result); |
| }); |
| this.on("error", function(err) { |
| this.reset(); |
| return cb(err); |
| }); |
| } |
| try { |
| str = str.toString(); |
| if (str.trim() === '') { |
| this.emit("end", null); |
| return true; |
| } |
| str = bom.stripBOM(str); |
| if (this.options.async) { |
| this.remaining = str; |
| setImmediate(this.processAsync); |
| return this.saxParser; |
| } |
| return this.saxParser.write(str).close(); |
| } catch (error1) { |
| err = error1; |
| if (!(this.saxParser.errThrown || this.saxParser.ended)) { |
| this.emit('error', err); |
| return this.saxParser.errThrown = true; |
| } else if (this.saxParser.ended) { |
| throw err; |
| } |
| } |
| }; |
| |
| Parser.prototype.parseStringPromise = function(str) { |
| return new Promise((function(_this) { |
| return function(resolve, reject) { |
| return _this.parseString(str, function(err, value) { |
| if (err) { |
| return reject(err); |
| } else { |
| return resolve(value); |
| } |
| }); |
| }; |
| })(this)); |
| }; |
| |
| return Parser; |
| |
| })(events); |
| |
| exports.parseString = function(str, a, b) { |
| var cb, options, parser; |
| if (b != null) { |
| if (typeof b === 'function') { |
| cb = b; |
| } |
| if (typeof a === 'object') { |
| options = a; |
| } |
| } else { |
| if (typeof a === 'function') { |
| cb = a; |
| } |
| options = {}; |
| } |
| parser = new exports.Parser(options); |
| return parser.parseString(str, cb); |
| }; |
| |
| exports.parseStringPromise = function(str, a) { |
| var options, parser; |
| if (typeof a === 'object') { |
| options = a; |
| } |
| parser = new exports.Parser(options); |
| return parser.parseStringPromise(str); |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 9236: |
| /***/ (function(__unused_webpack_module, exports) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| "use strict"; |
| var prefixMatch; |
| |
| prefixMatch = new RegExp(/(?!xmlns)^.*:/); |
| |
| exports.normalize = function(str) { |
| return str.toLowerCase(); |
| }; |
| |
| exports.firstCharLowerCase = function(str) { |
| return str.charAt(0).toLowerCase() + str.slice(1); |
| }; |
| |
| exports.stripPrefix = function(str) { |
| return str.replace(prefixMatch, ''); |
| }; |
| |
| exports.parseNumbers = function(str) { |
| if (!isNaN(str)) { |
| str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str); |
| } |
| return str; |
| }; |
| |
| exports.parseBooleans = function(str) { |
| if (/^(?:true|false)$/i.test(str)) { |
| str = str.toLowerCase() === 'true'; |
| } |
| return str; |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6189: |
| /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| "use strict"; |
| var builder, defaults, parser, processors, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| defaults = __nccwpck_require__(7251); |
| |
| builder = __nccwpck_require__(3337); |
| |
| parser = __nccwpck_require__(3314); |
| |
| processors = __nccwpck_require__(9236); |
| |
| exports.defaults = defaults.defaults; |
| |
| exports.processors = processors; |
| |
| exports.ValidationError = (function(superClass) { |
| extend(ValidationError, superClass); |
| |
| function ValidationError(message) { |
| this.message = message; |
| } |
| |
| return ValidationError; |
| |
| })(Error); |
| |
| exports.Builder = builder.Builder; |
| |
| exports.Parser = parser.Parser; |
| |
| exports.parseString = parser.parseString; |
| |
| exports.parseStringPromise = parser.parseStringPromise; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 2839: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| module.exports = { |
| Disconnected: 1, |
| Preceding: 2, |
| Following: 4, |
| Contains: 8, |
| ContainedBy: 16, |
| ImplementationSpecific: 32 |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 9267: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| module.exports = { |
| Element: 1, |
| Attribute: 2, |
| Text: 3, |
| CData: 4, |
| EntityReference: 5, |
| EntityDeclaration: 6, |
| ProcessingInstruction: 7, |
| Comment: 8, |
| Document: 9, |
| DocType: 10, |
| DocumentFragment: 11, |
| NotationDeclaration: 12, |
| Declaration: 201, |
| Raw: 202, |
| AttributeDeclaration: 203, |
| ElementDeclaration: 204, |
| Dummy: 205 |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 8229: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject, |
| slice = [].slice, |
| hasProp = {}.hasOwnProperty; |
| |
| assign = function() { |
| var i, key, len, source, sources, target; |
| target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : []; |
| if (isFunction(Object.assign)) { |
| Object.assign.apply(null, arguments); |
| } else { |
| for (i = 0, len = sources.length; i < len; i++) { |
| source = sources[i]; |
| if (source != null) { |
| for (key in source) { |
| if (!hasProp.call(source, key)) continue; |
| target[key] = source[key]; |
| } |
| } |
| } |
| } |
| return target; |
| }; |
| |
| isFunction = function(val) { |
| return !!val && Object.prototype.toString.call(val) === '[object Function]'; |
| }; |
| |
| isObject = function(val) { |
| var ref; |
| return !!val && ((ref = typeof val) === 'function' || ref === 'object'); |
| }; |
| |
| isArray = function(val) { |
| if (isFunction(Array.isArray)) { |
| return Array.isArray(val); |
| } else { |
| return Object.prototype.toString.call(val) === '[object Array]'; |
| } |
| }; |
| |
| isEmpty = function(val) { |
| var key; |
| if (isArray(val)) { |
| return !val.length; |
| } else { |
| for (key in val) { |
| if (!hasProp.call(val, key)) continue; |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| isPlainObject = function(val) { |
| var ctor, proto; |
| return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object)); |
| }; |
| |
| getValue = function(obj) { |
| if (isFunction(obj.valueOf)) { |
| return obj.valueOf(); |
| } else { |
| return obj; |
| } |
| }; |
| |
| module.exports.assign = assign; |
| |
| module.exports.isFunction = isFunction; |
| |
| module.exports.isObject = isObject; |
| |
| module.exports.isArray = isArray; |
| |
| module.exports.isEmpty = isEmpty; |
| |
| module.exports.isPlainObject = isPlainObject; |
| |
| module.exports.getValue = getValue; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 9766: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| module.exports = { |
| None: 0, |
| OpenTag: 1, |
| InsideTag: 2, |
| CloseTag: 3 |
| }; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 8376: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLAttribute, XMLNode; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| module.exports = XMLAttribute = (function() { |
| function XMLAttribute(parent, name, value) { |
| this.parent = parent; |
| if (this.parent) { |
| this.options = this.parent.options; |
| this.stringify = this.parent.stringify; |
| } |
| if (name == null) { |
| throw new Error("Missing attribute name. " + this.debugInfo(name)); |
| } |
| this.name = this.stringify.name(name); |
| this.value = this.stringify.attValue(value); |
| this.type = NodeType.Attribute; |
| this.isId = false; |
| this.schemaTypeInfo = null; |
| } |
| |
| Object.defineProperty(XMLAttribute.prototype, 'nodeType', { |
| get: function() { |
| return this.type; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'ownerElement', { |
| get: function() { |
| return this.parent; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'textContent', { |
| get: function() { |
| return this.value; |
| }, |
| set: function(value) { |
| return this.value = value || ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', { |
| get: function() { |
| return ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'prefix', { |
| get: function() { |
| return ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'localName', { |
| get: function() { |
| return this.name; |
| } |
| }); |
| |
| Object.defineProperty(XMLAttribute.prototype, 'specified', { |
| get: function() { |
| return true; |
| } |
| }); |
| |
| XMLAttribute.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLAttribute.prototype.toString = function(options) { |
| return this.options.writer.attribute(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLAttribute.prototype.debugInfo = function(name) { |
| name = name || this.name; |
| if (name == null) { |
| return "parent: <" + this.parent.name + ">"; |
| } else { |
| return "attribute: {" + name + "}, parent: <" + this.parent.name + ">"; |
| } |
| }; |
| |
| XMLAttribute.prototype.isEqualNode = function(node) { |
| if (node.namespaceURI !== this.namespaceURI) { |
| return false; |
| } |
| if (node.prefix !== this.prefix) { |
| return false; |
| } |
| if (node.localName !== this.localName) { |
| return false; |
| } |
| if (node.value !== this.value) { |
| return false; |
| } |
| return true; |
| }; |
| |
| return XMLAttribute; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 333: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLCData, XMLCharacterData, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLCharacterData = __nccwpck_require__(7709); |
| |
| module.exports = XMLCData = (function(superClass) { |
| extend(XMLCData, superClass); |
| |
| function XMLCData(parent, text) { |
| XMLCData.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing CDATA text. " + this.debugInfo()); |
| } |
| this.name = "#cdata-section"; |
| this.type = NodeType.CData; |
| this.value = this.stringify.cdata(text); |
| } |
| |
| XMLCData.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLCData.prototype.toString = function(options) { |
| return this.options.writer.cdata(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLCData; |
| |
| })(XMLCharacterData); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7709: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLCharacterData, XMLNode, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| module.exports = XMLCharacterData = (function(superClass) { |
| extend(XMLCharacterData, superClass); |
| |
| function XMLCharacterData(parent) { |
| XMLCharacterData.__super__.constructor.call(this, parent); |
| this.value = ''; |
| } |
| |
| Object.defineProperty(XMLCharacterData.prototype, 'data', { |
| get: function() { |
| return this.value; |
| }, |
| set: function(value) { |
| return this.value = value || ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLCharacterData.prototype, 'length', { |
| get: function() { |
| return this.value.length; |
| } |
| }); |
| |
| Object.defineProperty(XMLCharacterData.prototype, 'textContent', { |
| get: function() { |
| return this.value; |
| }, |
| set: function(value) { |
| return this.value = value || ''; |
| } |
| }); |
| |
| XMLCharacterData.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLCharacterData.prototype.substringData = function(offset, count) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLCharacterData.prototype.appendData = function(arg) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLCharacterData.prototype.insertData = function(offset, arg) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLCharacterData.prototype.deleteData = function(offset, count) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLCharacterData.prototype.replaceData = function(offset, count, arg) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLCharacterData.prototype.isEqualNode = function(node) { |
| if (!XMLCharacterData.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) { |
| return false; |
| } |
| if (node.data !== this.data) { |
| return false; |
| } |
| return true; |
| }; |
| |
| return XMLCharacterData; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 4407: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLCharacterData, XMLComment, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLCharacterData = __nccwpck_require__(7709); |
| |
| module.exports = XMLComment = (function(superClass) { |
| extend(XMLComment, superClass); |
| |
| function XMLComment(parent, text) { |
| XMLComment.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing comment text. " + this.debugInfo()); |
| } |
| this.name = "#comment"; |
| this.type = NodeType.Comment; |
| this.value = this.stringify.comment(text); |
| } |
| |
| XMLComment.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLComment.prototype.toString = function(options) { |
| return this.options.writer.comment(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLComment; |
| |
| })(XMLCharacterData); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7465: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList; |
| |
| XMLDOMErrorHandler = __nccwpck_require__(6744); |
| |
| XMLDOMStringList = __nccwpck_require__(7028); |
| |
| module.exports = XMLDOMConfiguration = (function() { |
| function XMLDOMConfiguration() { |
| var clonedSelf; |
| this.defaultParams = { |
| "canonical-form": false, |
| "cdata-sections": false, |
| "comments": false, |
| "datatype-normalization": false, |
| "element-content-whitespace": true, |
| "entities": true, |
| "error-handler": new XMLDOMErrorHandler(), |
| "infoset": true, |
| "validate-if-schema": false, |
| "namespaces": true, |
| "namespace-declarations": true, |
| "normalize-characters": false, |
| "schema-location": '', |
| "schema-type": '', |
| "split-cdata-sections": true, |
| "validate": false, |
| "well-formed": true |
| }; |
| this.params = clonedSelf = Object.create(this.defaultParams); |
| } |
| |
| Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', { |
| get: function() { |
| return new XMLDOMStringList(Object.keys(this.defaultParams)); |
| } |
| }); |
| |
| XMLDOMConfiguration.prototype.getParameter = function(name) { |
| if (this.params.hasOwnProperty(name)) { |
| return this.params[name]; |
| } else { |
| return null; |
| } |
| }; |
| |
| XMLDOMConfiguration.prototype.canSetParameter = function(name, value) { |
| return true; |
| }; |
| |
| XMLDOMConfiguration.prototype.setParameter = function(name, value) { |
| if (value != null) { |
| return this.params[name] = value; |
| } else { |
| return delete this.params[name]; |
| } |
| }; |
| |
| return XMLDOMConfiguration; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6744: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLDOMErrorHandler; |
| |
| module.exports = XMLDOMErrorHandler = (function() { |
| function XMLDOMErrorHandler() {} |
| |
| XMLDOMErrorHandler.prototype.handleError = function(error) { |
| throw new Error(error); |
| }; |
| |
| return XMLDOMErrorHandler; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 8310: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLDOMImplementation; |
| |
| module.exports = XMLDOMImplementation = (function() { |
| function XMLDOMImplementation() {} |
| |
| XMLDOMImplementation.prototype.hasFeature = function(feature, version) { |
| return true; |
| }; |
| |
| XMLDOMImplementation.prototype.createDocumentType = function(qualifiedName, publicId, systemId) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| XMLDOMImplementation.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| XMLDOMImplementation.prototype.createHTMLDocument = function(title) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| XMLDOMImplementation.prototype.getFeature = function(feature, version) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| return XMLDOMImplementation; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7028: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLDOMStringList; |
| |
| module.exports = XMLDOMStringList = (function() { |
| function XMLDOMStringList(arr) { |
| this.arr = arr || []; |
| } |
| |
| Object.defineProperty(XMLDOMStringList.prototype, 'length', { |
| get: function() { |
| return this.arr.length; |
| } |
| }); |
| |
| XMLDOMStringList.prototype.item = function(index) { |
| return this.arr[index] || null; |
| }; |
| |
| XMLDOMStringList.prototype.contains = function(str) { |
| return this.arr.indexOf(str) !== -1; |
| }; |
| |
| return XMLDOMStringList; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 1015: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDTDAttList, XMLNode, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDTDAttList = (function(superClass) { |
| extend(XMLDTDAttList, superClass); |
| |
| function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| XMLDTDAttList.__super__.constructor.call(this, parent); |
| if (elementName == null) { |
| throw new Error("Missing DTD element name. " + this.debugInfo()); |
| } |
| if (attributeName == null) { |
| throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName)); |
| } |
| if (!attributeType) { |
| throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName)); |
| } |
| if (!defaultValueType) { |
| throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName)); |
| } |
| if (defaultValueType.indexOf('#') !== 0) { |
| defaultValueType = '#' + defaultValueType; |
| } |
| if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) { |
| throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName)); |
| } |
| if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) { |
| throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName)); |
| } |
| this.elementName = this.stringify.name(elementName); |
| this.type = NodeType.AttributeDeclaration; |
| this.attributeName = this.stringify.name(attributeName); |
| this.attributeType = this.stringify.dtdAttType(attributeType); |
| if (defaultValue) { |
| this.defaultValue = this.stringify.dtdAttDefault(defaultValue); |
| } |
| this.defaultValueType = defaultValueType; |
| } |
| |
| XMLDTDAttList.prototype.toString = function(options) { |
| return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLDTDAttList; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 2421: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDTDElement, XMLNode, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDTDElement = (function(superClass) { |
| extend(XMLDTDElement, superClass); |
| |
| function XMLDTDElement(parent, name, value) { |
| XMLDTDElement.__super__.constructor.call(this, parent); |
| if (name == null) { |
| throw new Error("Missing DTD element name. " + this.debugInfo()); |
| } |
| if (!value) { |
| value = '(#PCDATA)'; |
| } |
| if (Array.isArray(value)) { |
| value = '(' + value.join(',') + ')'; |
| } |
| this.name = this.stringify.name(name); |
| this.type = NodeType.ElementDeclaration; |
| this.value = this.stringify.dtdElementValue(value); |
| } |
| |
| XMLDTDElement.prototype.toString = function(options) { |
| return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLDTDElement; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 53: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDTDEntity, XMLNode, isObject, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| isObject = __nccwpck_require__(8229).isObject; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDTDEntity = (function(superClass) { |
| extend(XMLDTDEntity, superClass); |
| |
| function XMLDTDEntity(parent, pe, name, value) { |
| XMLDTDEntity.__super__.constructor.call(this, parent); |
| if (name == null) { |
| throw new Error("Missing DTD entity name. " + this.debugInfo(name)); |
| } |
| if (value == null) { |
| throw new Error("Missing DTD entity value. " + this.debugInfo(name)); |
| } |
| this.pe = !!pe; |
| this.name = this.stringify.name(name); |
| this.type = NodeType.EntityDeclaration; |
| if (!isObject(value)) { |
| this.value = this.stringify.dtdEntityValue(value); |
| this.internal = true; |
| } else { |
| if (!value.pubID && !value.sysID) { |
| throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name)); |
| } |
| if (value.pubID && !value.sysID) { |
| throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name)); |
| } |
| this.internal = false; |
| if (value.pubID != null) { |
| this.pubID = this.stringify.dtdPubID(value.pubID); |
| } |
| if (value.sysID != null) { |
| this.sysID = this.stringify.dtdSysID(value.sysID); |
| } |
| if (value.nData != null) { |
| this.nData = this.stringify.dtdNData(value.nData); |
| } |
| if (this.pe && this.nData) { |
| throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name)); |
| } |
| } |
| } |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'publicId', { |
| get: function() { |
| return this.pubID; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'systemId', { |
| get: function() { |
| return this.sysID; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'notationName', { |
| get: function() { |
| return this.nData || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| XMLDTDEntity.prototype.toString = function(options) { |
| return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLDTDEntity; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 2837: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDTDNotation, XMLNode, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDTDNotation = (function(superClass) { |
| extend(XMLDTDNotation, superClass); |
| |
| function XMLDTDNotation(parent, name, value) { |
| XMLDTDNotation.__super__.constructor.call(this, parent); |
| if (name == null) { |
| throw new Error("Missing DTD notation name. " + this.debugInfo(name)); |
| } |
| if (!value.pubID && !value.sysID) { |
| throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name)); |
| } |
| this.name = this.stringify.name(name); |
| this.type = NodeType.NotationDeclaration; |
| if (value.pubID != null) { |
| this.pubID = this.stringify.dtdPubID(value.pubID); |
| } |
| if (value.sysID != null) { |
| this.sysID = this.stringify.dtdSysID(value.sysID); |
| } |
| } |
| |
| Object.defineProperty(XMLDTDNotation.prototype, 'publicId', { |
| get: function() { |
| return this.pubID; |
| } |
| }); |
| |
| Object.defineProperty(XMLDTDNotation.prototype, 'systemId', { |
| get: function() { |
| return this.sysID; |
| } |
| }); |
| |
| XMLDTDNotation.prototype.toString = function(options) { |
| return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLDTDNotation; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6364: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDeclaration, XMLNode, isObject, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| isObject = __nccwpck_require__(8229).isObject; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDeclaration = (function(superClass) { |
| extend(XMLDeclaration, superClass); |
| |
| function XMLDeclaration(parent, version, encoding, standalone) { |
| var ref; |
| XMLDeclaration.__super__.constructor.call(this, parent); |
| if (isObject(version)) { |
| ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone; |
| } |
| if (!version) { |
| version = '1.0'; |
| } |
| this.type = NodeType.Declaration; |
| this.version = this.stringify.xmlVersion(version); |
| if (encoding != null) { |
| this.encoding = this.stringify.xmlEncoding(encoding); |
| } |
| if (standalone != null) { |
| this.standalone = this.stringify.xmlStandalone(standalone); |
| } |
| } |
| |
| XMLDeclaration.prototype.toString = function(options) { |
| return this.options.writer.declaration(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLDeclaration; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 1801: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| isObject = __nccwpck_require__(8229).isObject; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLDTDAttList = __nccwpck_require__(1015); |
| |
| XMLDTDEntity = __nccwpck_require__(53); |
| |
| XMLDTDElement = __nccwpck_require__(2421); |
| |
| XMLDTDNotation = __nccwpck_require__(2837); |
| |
| XMLNamedNodeMap = __nccwpck_require__(4361); |
| |
| module.exports = XMLDocType = (function(superClass) { |
| extend(XMLDocType, superClass); |
| |
| function XMLDocType(parent, pubID, sysID) { |
| var child, i, len, ref, ref1, ref2; |
| XMLDocType.__super__.constructor.call(this, parent); |
| this.type = NodeType.DocType; |
| if (parent.children) { |
| ref = parent.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| if (child.type === NodeType.Element) { |
| this.name = child.name; |
| break; |
| } |
| } |
| } |
| this.documentObject = parent; |
| if (isObject(pubID)) { |
| ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID; |
| } |
| if (sysID == null) { |
| ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1]; |
| } |
| if (pubID != null) { |
| this.pubID = this.stringify.dtdPubID(pubID); |
| } |
| if (sysID != null) { |
| this.sysID = this.stringify.dtdSysID(sysID); |
| } |
| } |
| |
| Object.defineProperty(XMLDocType.prototype, 'entities', { |
| get: function() { |
| var child, i, len, nodes, ref; |
| nodes = {}; |
| ref = this.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| if ((child.type === NodeType.EntityDeclaration) && !child.pe) { |
| nodes[child.name] = child; |
| } |
| } |
| return new XMLNamedNodeMap(nodes); |
| } |
| }); |
| |
| Object.defineProperty(XMLDocType.prototype, 'notations', { |
| get: function() { |
| var child, i, len, nodes, ref; |
| nodes = {}; |
| ref = this.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| if (child.type === NodeType.NotationDeclaration) { |
| nodes[child.name] = child; |
| } |
| } |
| return new XMLNamedNodeMap(nodes); |
| } |
| }); |
| |
| Object.defineProperty(XMLDocType.prototype, 'publicId', { |
| get: function() { |
| return this.pubID; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocType.prototype, 'systemId', { |
| get: function() { |
| return this.sysID; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocType.prototype, 'internalSubset', { |
| get: function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| XMLDocType.prototype.element = function(name, value) { |
| var child; |
| child = new XMLDTDElement(this, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| var child; |
| child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.entity = function(name, value) { |
| var child; |
| child = new XMLDTDEntity(this, false, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.pEntity = function(name, value) { |
| var child; |
| child = new XMLDTDEntity(this, true, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.notation = function(name, value) { |
| var child; |
| child = new XMLDTDNotation(this, name, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLDocType.prototype.toString = function(options) { |
| return this.options.writer.docType(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLDocType.prototype.ele = function(name, value) { |
| return this.element(name, value); |
| }; |
| |
| XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue); |
| }; |
| |
| XMLDocType.prototype.ent = function(name, value) { |
| return this.entity(name, value); |
| }; |
| |
| XMLDocType.prototype.pent = function(name, value) { |
| return this.pEntity(name, value); |
| }; |
| |
| XMLDocType.prototype.not = function(name, value) { |
| return this.notation(name, value); |
| }; |
| |
| XMLDocType.prototype.up = function() { |
| return this.root() || this.documentObject; |
| }; |
| |
| XMLDocType.prototype.isEqualNode = function(node) { |
| if (!XMLDocType.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) { |
| return false; |
| } |
| if (node.name !== this.name) { |
| return false; |
| } |
| if (node.publicId !== this.publicId) { |
| return false; |
| } |
| if (node.systemId !== this.systemId) { |
| return false; |
| } |
| return true; |
| }; |
| |
| return XMLDocType; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 3730: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| isPlainObject = __nccwpck_require__(8229).isPlainObject; |
| |
| XMLDOMImplementation = __nccwpck_require__(8310); |
| |
| XMLDOMConfiguration = __nccwpck_require__(7465); |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLStringifier = __nccwpck_require__(8594); |
| |
| XMLStringWriter = __nccwpck_require__(5913); |
| |
| module.exports = XMLDocument = (function(superClass) { |
| extend(XMLDocument, superClass); |
| |
| function XMLDocument(options) { |
| XMLDocument.__super__.constructor.call(this, null); |
| this.name = "#document"; |
| this.type = NodeType.Document; |
| this.documentURI = null; |
| this.domConfig = new XMLDOMConfiguration(); |
| options || (options = {}); |
| if (!options.writer) { |
| options.writer = new XMLStringWriter(); |
| } |
| this.options = options; |
| this.stringify = new XMLStringifier(options); |
| } |
| |
| Object.defineProperty(XMLDocument.prototype, 'implementation', { |
| value: new XMLDOMImplementation() |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'doctype', { |
| get: function() { |
| var child, i, len, ref; |
| ref = this.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| if (child.type === NodeType.DocType) { |
| return child; |
| } |
| } |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'documentElement', { |
| get: function() { |
| return this.rootObject || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'inputEncoding', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'strictErrorChecking', { |
| get: function() { |
| return false; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'xmlEncoding', { |
| get: function() { |
| if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) { |
| return this.children[0].encoding; |
| } else { |
| return null; |
| } |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'xmlStandalone', { |
| get: function() { |
| if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) { |
| return this.children[0].standalone === 'yes'; |
| } else { |
| return false; |
| } |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'xmlVersion', { |
| get: function() { |
| if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) { |
| return this.children[0].version; |
| } else { |
| return "1.0"; |
| } |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'URL', { |
| get: function() { |
| return this.documentURI; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'origin', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'compatMode', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'characterSet', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| Object.defineProperty(XMLDocument.prototype, 'contentType', { |
| get: function() { |
| return null; |
| } |
| }); |
| |
| XMLDocument.prototype.end = function(writer) { |
| var writerOptions; |
| writerOptions = {}; |
| if (!writer) { |
| writer = this.options.writer; |
| } else if (isPlainObject(writer)) { |
| writerOptions = writer; |
| writer = this.options.writer; |
| } |
| return writer.document(this, writer.filterOptions(writerOptions)); |
| }; |
| |
| XMLDocument.prototype.toString = function(options) { |
| return this.options.writer.document(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLDocument.prototype.createElement = function(tagName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createDocumentFragment = function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createTextNode = function(data) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createComment = function(data) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createCDATASection = function(data) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createProcessingInstruction = function(target, data) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createAttribute = function(name) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createEntityReference = function(name) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.getElementsByTagName = function(tagname) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.importNode = function(importedNode, deep) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createElementNS = function(namespaceURI, qualifiedName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createAttributeNS = function(namespaceURI, qualifiedName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.getElementsByTagNameNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.getElementById = function(elementId) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.adoptNode = function(source) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.normalizeDocument = function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.renameNode = function(node, namespaceURI, qualifiedName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.getElementsByClassName = function(classNames) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createEvent = function(eventInterface) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createRange = function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createNodeIterator = function(root, whatToShow, filter) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLDocument.prototype.createTreeWalker = function(root, whatToShow, filter) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| return XMLDocument; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7356: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref, |
| hasProp = {}.hasOwnProperty; |
| |
| ref = __nccwpck_require__(8229), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLDocument = __nccwpck_require__(3730); |
| |
| XMLElement = __nccwpck_require__(9437); |
| |
| XMLCData = __nccwpck_require__(333); |
| |
| XMLComment = __nccwpck_require__(4407); |
| |
| XMLRaw = __nccwpck_require__(6329); |
| |
| XMLText = __nccwpck_require__(1318); |
| |
| XMLProcessingInstruction = __nccwpck_require__(6939); |
| |
| XMLDeclaration = __nccwpck_require__(6364); |
| |
| XMLDocType = __nccwpck_require__(1801); |
| |
| XMLDTDAttList = __nccwpck_require__(1015); |
| |
| XMLDTDEntity = __nccwpck_require__(53); |
| |
| XMLDTDElement = __nccwpck_require__(2421); |
| |
| XMLDTDNotation = __nccwpck_require__(2837); |
| |
| XMLAttribute = __nccwpck_require__(8376); |
| |
| XMLStringifier = __nccwpck_require__(8594); |
| |
| XMLStringWriter = __nccwpck_require__(5913); |
| |
| WriterState = __nccwpck_require__(9766); |
| |
| module.exports = XMLDocumentCB = (function() { |
| function XMLDocumentCB(options, onData, onEnd) { |
| var writerOptions; |
| this.name = "?xml"; |
| this.type = NodeType.Document; |
| options || (options = {}); |
| writerOptions = {}; |
| if (!options.writer) { |
| options.writer = new XMLStringWriter(); |
| } else if (isPlainObject(options.writer)) { |
| writerOptions = options.writer; |
| options.writer = new XMLStringWriter(); |
| } |
| this.options = options; |
| this.writer = options.writer; |
| this.writerOptions = this.writer.filterOptions(writerOptions); |
| this.stringify = new XMLStringifier(options); |
| this.onDataCallback = onData || function() {}; |
| this.onEndCallback = onEnd || function() {}; |
| this.currentNode = null; |
| this.currentLevel = -1; |
| this.openTags = {}; |
| this.documentStarted = false; |
| this.documentCompleted = false; |
| this.root = null; |
| } |
| |
| XMLDocumentCB.prototype.createChildNode = function(node) { |
| var att, attName, attributes, child, i, len, ref1, ref2; |
| switch (node.type) { |
| case NodeType.CData: |
| this.cdata(node.value); |
| break; |
| case NodeType.Comment: |
| this.comment(node.value); |
| break; |
| case NodeType.Element: |
| attributes = {}; |
| ref1 = node.attribs; |
| for (attName in ref1) { |
| if (!hasProp.call(ref1, attName)) continue; |
| att = ref1[attName]; |
| attributes[attName] = att.value; |
| } |
| this.node(node.name, attributes); |
| break; |
| case NodeType.Dummy: |
| this.dummy(); |
| break; |
| case NodeType.Raw: |
| this.raw(node.value); |
| break; |
| case NodeType.Text: |
| this.text(node.value); |
| break; |
| case NodeType.ProcessingInstruction: |
| this.instruction(node.target, node.value); |
| break; |
| default: |
| throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name); |
| } |
| ref2 = node.children; |
| for (i = 0, len = ref2.length; i < len; i++) { |
| child = ref2[i]; |
| this.createChildNode(child); |
| if (child.type === NodeType.Element) { |
| this.up(); |
| } |
| } |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.dummy = function() { |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.node = function(name, attributes, text) { |
| var ref1; |
| if (name == null) { |
| throw new Error("Missing node name."); |
| } |
| if (this.root && this.currentLevel === -1) { |
| throw new Error("Document can only have one root node. " + this.debugInfo(name)); |
| } |
| this.openCurrent(); |
| name = getValue(name); |
| if (attributes == null) { |
| attributes = {}; |
| } |
| attributes = getValue(attributes); |
| if (!isObject(attributes)) { |
| ref1 = [attributes, text], text = ref1[0], attributes = ref1[1]; |
| } |
| this.currentNode = new XMLElement(this, name, attributes); |
| this.currentNode.children = false; |
| this.currentLevel++; |
| this.openTags[this.currentLevel] = this.currentNode; |
| if (text != null) { |
| this.text(text); |
| } |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.element = function(name, attributes, text) { |
| var child, i, len, oldValidationFlag, ref1, root; |
| if (this.currentNode && this.currentNode.type === NodeType.DocType) { |
| this.dtdElement.apply(this, arguments); |
| } else { |
| if (Array.isArray(name) || isObject(name) || isFunction(name)) { |
| oldValidationFlag = this.options.noValidation; |
| this.options.noValidation = true; |
| root = new XMLDocument(this.options).element('TEMP_ROOT'); |
| root.element(name); |
| this.options.noValidation = oldValidationFlag; |
| ref1 = root.children; |
| for (i = 0, len = ref1.length; i < len; i++) { |
| child = ref1[i]; |
| this.createChildNode(child); |
| if (child.type === NodeType.Element) { |
| this.up(); |
| } |
| } |
| } else { |
| this.node(name, attributes, text); |
| } |
| } |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.attribute = function(name, value) { |
| var attName, attValue; |
| if (!this.currentNode || this.currentNode.children) { |
| throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name)); |
| } |
| if (name != null) { |
| name = getValue(name); |
| } |
| if (isObject(name)) { |
| for (attName in name) { |
| if (!hasProp.call(name, attName)) continue; |
| attValue = name[attName]; |
| this.attribute(attName, attValue); |
| } |
| } else { |
| if (isFunction(value)) { |
| value = value.apply(); |
| } |
| if (this.options.keepNullAttributes && (value == null)) { |
| this.currentNode.attribs[name] = new XMLAttribute(this, name, ""); |
| } else if (value != null) { |
| this.currentNode.attribs[name] = new XMLAttribute(this, name, value); |
| } |
| } |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.text = function(value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLText(this, value); |
| this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.cdata = function(value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLCData(this, value); |
| this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.comment = function(value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLComment(this, value); |
| this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.raw = function(value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLRaw(this, value); |
| this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.instruction = function(target, value) { |
| var i, insTarget, insValue, len, node; |
| this.openCurrent(); |
| if (target != null) { |
| target = getValue(target); |
| } |
| if (value != null) { |
| value = getValue(value); |
| } |
| if (Array.isArray(target)) { |
| for (i = 0, len = target.length; i < len; i++) { |
| insTarget = target[i]; |
| this.instruction(insTarget); |
| } |
| } else if (isObject(target)) { |
| for (insTarget in target) { |
| if (!hasProp.call(target, insTarget)) continue; |
| insValue = target[insTarget]; |
| this.instruction(insTarget, insValue); |
| } |
| } else { |
| if (isFunction(value)) { |
| value = value.apply(); |
| } |
| node = new XMLProcessingInstruction(this, target, value); |
| this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| } |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.declaration = function(version, encoding, standalone) { |
| var node; |
| this.openCurrent(); |
| if (this.documentStarted) { |
| throw new Error("declaration() must be the first node."); |
| } |
| node = new XMLDeclaration(this, version, encoding, standalone); |
| this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.doctype = function(root, pubID, sysID) { |
| this.openCurrent(); |
| if (root == null) { |
| throw new Error("Missing root node name."); |
| } |
| if (this.root) { |
| throw new Error("dtd() must come before the root node."); |
| } |
| this.currentNode = new XMLDocType(this, pubID, sysID); |
| this.currentNode.rootNodeName = root; |
| this.currentNode.children = false; |
| this.currentLevel++; |
| this.openTags[this.currentLevel] = this.currentNode; |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.dtdElement = function(name, value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLDTDElement(this, name, value); |
| this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) { |
| var node; |
| this.openCurrent(); |
| node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue); |
| this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.entity = function(name, value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLDTDEntity(this, false, name, value); |
| this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.pEntity = function(name, value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLDTDEntity(this, true, name, value); |
| this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.notation = function(name, value) { |
| var node; |
| this.openCurrent(); |
| node = new XMLDTDNotation(this, name, value); |
| this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1); |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.up = function() { |
| if (this.currentLevel < 0) { |
| throw new Error("The document node has no parent."); |
| } |
| if (this.currentNode) { |
| if (this.currentNode.children) { |
| this.closeNode(this.currentNode); |
| } else { |
| this.openNode(this.currentNode); |
| } |
| this.currentNode = null; |
| } else { |
| this.closeNode(this.openTags[this.currentLevel]); |
| } |
| delete this.openTags[this.currentLevel]; |
| this.currentLevel--; |
| return this; |
| }; |
| |
| XMLDocumentCB.prototype.end = function() { |
| while (this.currentLevel >= 0) { |
| this.up(); |
| } |
| return this.onEnd(); |
| }; |
| |
| XMLDocumentCB.prototype.openCurrent = function() { |
| if (this.currentNode) { |
| this.currentNode.children = true; |
| return this.openNode(this.currentNode); |
| } |
| }; |
| |
| XMLDocumentCB.prototype.openNode = function(node) { |
| var att, chunk, name, ref1; |
| if (!node.isOpen) { |
| if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) { |
| this.root = node; |
| } |
| chunk = ''; |
| if (node.type === NodeType.Element) { |
| this.writerOptions.state = WriterState.OpenTag; |
| chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<' + node.name; |
| ref1 = node.attribs; |
| for (name in ref1) { |
| if (!hasProp.call(ref1, name)) continue; |
| att = ref1[name]; |
| chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel); |
| } |
| chunk += (node.children ? '>' : '/>') + this.writer.endline(node, this.writerOptions, this.currentLevel); |
| this.writerOptions.state = WriterState.InsideTag; |
| } else { |
| this.writerOptions.state = WriterState.OpenTag; |
| chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<!DOCTYPE ' + node.rootNodeName; |
| if (node.pubID && node.sysID) { |
| chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"'; |
| } else if (node.sysID) { |
| chunk += ' SYSTEM "' + node.sysID + '"'; |
| } |
| if (node.children) { |
| chunk += ' ['; |
| this.writerOptions.state = WriterState.InsideTag; |
| } else { |
| this.writerOptions.state = WriterState.CloseTag; |
| chunk += '>'; |
| } |
| chunk += this.writer.endline(node, this.writerOptions, this.currentLevel); |
| } |
| this.onData(chunk, this.currentLevel); |
| return node.isOpen = true; |
| } |
| }; |
| |
| XMLDocumentCB.prototype.closeNode = function(node) { |
| var chunk; |
| if (!node.isClosed) { |
| chunk = ''; |
| this.writerOptions.state = WriterState.CloseTag; |
| if (node.type === NodeType.Element) { |
| chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '</' + node.name + '>' + this.writer.endline(node, this.writerOptions, this.currentLevel); |
| } else { |
| chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + ']>' + this.writer.endline(node, this.writerOptions, this.currentLevel); |
| } |
| this.writerOptions.state = WriterState.None; |
| this.onData(chunk, this.currentLevel); |
| return node.isClosed = true; |
| } |
| }; |
| |
| XMLDocumentCB.prototype.onData = function(chunk, level) { |
| this.documentStarted = true; |
| return this.onDataCallback(chunk, level + 1); |
| }; |
| |
| XMLDocumentCB.prototype.onEnd = function() { |
| this.documentCompleted = true; |
| return this.onEndCallback(); |
| }; |
| |
| XMLDocumentCB.prototype.debugInfo = function(name) { |
| if (name == null) { |
| return ""; |
| } else { |
| return "node: <" + name + ">"; |
| } |
| }; |
| |
| XMLDocumentCB.prototype.ele = function() { |
| return this.element.apply(this, arguments); |
| }; |
| |
| XMLDocumentCB.prototype.nod = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLDocumentCB.prototype.txt = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLDocumentCB.prototype.dat = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLDocumentCB.prototype.com = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLDocumentCB.prototype.ins = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLDocumentCB.prototype.dec = function(version, encoding, standalone) { |
| return this.declaration(version, encoding, standalone); |
| }; |
| |
| XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) { |
| return this.doctype(root, pubID, sysID); |
| }; |
| |
| XMLDocumentCB.prototype.e = function(name, attributes, text) { |
| return this.element(name, attributes, text); |
| }; |
| |
| XMLDocumentCB.prototype.n = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLDocumentCB.prototype.t = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLDocumentCB.prototype.d = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLDocumentCB.prototype.c = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLDocumentCB.prototype.r = function(value) { |
| return this.raw(value); |
| }; |
| |
| XMLDocumentCB.prototype.i = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLDocumentCB.prototype.att = function() { |
| if (this.currentNode && this.currentNode.type === NodeType.DocType) { |
| return this.attList.apply(this, arguments); |
| } else { |
| return this.attribute.apply(this, arguments); |
| } |
| }; |
| |
| XMLDocumentCB.prototype.a = function() { |
| if (this.currentNode && this.currentNode.type === NodeType.DocType) { |
| return this.attList.apply(this, arguments); |
| } else { |
| return this.attribute.apply(this, arguments); |
| } |
| }; |
| |
| XMLDocumentCB.prototype.ent = function(name, value) { |
| return this.entity(name, value); |
| }; |
| |
| XMLDocumentCB.prototype.pent = function(name, value) { |
| return this.pEntity(name, value); |
| }; |
| |
| XMLDocumentCB.prototype.not = function(name, value) { |
| return this.notation(name, value); |
| }; |
| |
| return XMLDocumentCB; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 3590: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLDummy, XMLNode, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| module.exports = XMLDummy = (function(superClass) { |
| extend(XMLDummy, superClass); |
| |
| function XMLDummy(parent) { |
| XMLDummy.__super__.constructor.call(this, parent); |
| this.type = NodeType.Dummy; |
| } |
| |
| XMLDummy.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLDummy.prototype.toString = function(options) { |
| return ''; |
| }; |
| |
| return XMLDummy; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 9437: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| ref = __nccwpck_require__(8229), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue; |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLAttribute = __nccwpck_require__(8376); |
| |
| XMLNamedNodeMap = __nccwpck_require__(4361); |
| |
| module.exports = XMLElement = (function(superClass) { |
| extend(XMLElement, superClass); |
| |
| function XMLElement(parent, name, attributes) { |
| var child, j, len, ref1; |
| XMLElement.__super__.constructor.call(this, parent); |
| if (name == null) { |
| throw new Error("Missing element name. " + this.debugInfo()); |
| } |
| this.name = this.stringify.name(name); |
| this.type = NodeType.Element; |
| this.attribs = {}; |
| this.schemaTypeInfo = null; |
| if (attributes != null) { |
| this.attribute(attributes); |
| } |
| if (parent.type === NodeType.Document) { |
| this.isRoot = true; |
| this.documentObject = parent; |
| parent.rootObject = this; |
| if (parent.children) { |
| ref1 = parent.children; |
| for (j = 0, len = ref1.length; j < len; j++) { |
| child = ref1[j]; |
| if (child.type === NodeType.DocType) { |
| child.name = this.name; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| Object.defineProperty(XMLElement.prototype, 'tagName', { |
| get: function() { |
| return this.name; |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'namespaceURI', { |
| get: function() { |
| return ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'prefix', { |
| get: function() { |
| return ''; |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'localName', { |
| get: function() { |
| return this.name; |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'id', { |
| get: function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'className', { |
| get: function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'classList', { |
| get: function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| Object.defineProperty(XMLElement.prototype, 'attributes', { |
| get: function() { |
| if (!this.attributeMap || !this.attributeMap.nodes) { |
| this.attributeMap = new XMLNamedNodeMap(this.attribs); |
| } |
| return this.attributeMap; |
| } |
| }); |
| |
| XMLElement.prototype.clone = function() { |
| var att, attName, clonedSelf, ref1; |
| clonedSelf = Object.create(this); |
| if (clonedSelf.isRoot) { |
| clonedSelf.documentObject = null; |
| } |
| clonedSelf.attribs = {}; |
| ref1 = this.attribs; |
| for (attName in ref1) { |
| if (!hasProp.call(ref1, attName)) continue; |
| att = ref1[attName]; |
| clonedSelf.attribs[attName] = att.clone(); |
| } |
| clonedSelf.children = []; |
| this.children.forEach(function(child) { |
| var clonedChild; |
| clonedChild = child.clone(); |
| clonedChild.parent = clonedSelf; |
| return clonedSelf.children.push(clonedChild); |
| }); |
| return clonedSelf; |
| }; |
| |
| XMLElement.prototype.attribute = function(name, value) { |
| var attName, attValue; |
| if (name != null) { |
| name = getValue(name); |
| } |
| if (isObject(name)) { |
| for (attName in name) { |
| if (!hasProp.call(name, attName)) continue; |
| attValue = name[attName]; |
| this.attribute(attName, attValue); |
| } |
| } else { |
| if (isFunction(value)) { |
| value = value.apply(); |
| } |
| if (this.options.keepNullAttributes && (value == null)) { |
| this.attribs[name] = new XMLAttribute(this, name, ""); |
| } else if (value != null) { |
| this.attribs[name] = new XMLAttribute(this, name, value); |
| } |
| } |
| return this; |
| }; |
| |
| XMLElement.prototype.removeAttribute = function(name) { |
| var attName, j, len; |
| if (name == null) { |
| throw new Error("Missing attribute name. " + this.debugInfo()); |
| } |
| name = getValue(name); |
| if (Array.isArray(name)) { |
| for (j = 0, len = name.length; j < len; j++) { |
| attName = name[j]; |
| delete this.attribs[attName]; |
| } |
| } else { |
| delete this.attribs[name]; |
| } |
| return this; |
| }; |
| |
| XMLElement.prototype.toString = function(options) { |
| return this.options.writer.element(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLElement.prototype.att = function(name, value) { |
| return this.attribute(name, value); |
| }; |
| |
| XMLElement.prototype.a = function(name, value) { |
| return this.attribute(name, value); |
| }; |
| |
| XMLElement.prototype.getAttribute = function(name) { |
| if (this.attribs.hasOwnProperty(name)) { |
| return this.attribs[name].value; |
| } else { |
| return null; |
| } |
| }; |
| |
| XMLElement.prototype.setAttribute = function(name, value) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getAttributeNode = function(name) { |
| if (this.attribs.hasOwnProperty(name)) { |
| return this.attribs[name]; |
| } else { |
| return null; |
| } |
| }; |
| |
| XMLElement.prototype.setAttributeNode = function(newAttr) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.removeAttributeNode = function(oldAttr) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getElementsByTagName = function(name) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getAttributeNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.removeAttributeNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getAttributeNodeNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.setAttributeNodeNS = function(newAttr) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.hasAttribute = function(name) { |
| return this.attribs.hasOwnProperty(name); |
| }; |
| |
| XMLElement.prototype.hasAttributeNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.setIdAttribute = function(name, isId) { |
| if (this.attribs.hasOwnProperty(name)) { |
| return this.attribs[name].isId; |
| } else { |
| return isId; |
| } |
| }; |
| |
| XMLElement.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.setIdAttributeNode = function(idAttr, isId) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getElementsByTagName = function(tagname) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.getElementsByClassName = function(classNames) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLElement.prototype.isEqualNode = function(node) { |
| var i, j, ref1; |
| if (!XMLElement.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) { |
| return false; |
| } |
| if (node.namespaceURI !== this.namespaceURI) { |
| return false; |
| } |
| if (node.prefix !== this.prefix) { |
| return false; |
| } |
| if (node.localName !== this.localName) { |
| return false; |
| } |
| if (node.attribs.length !== this.attribs.length) { |
| return false; |
| } |
| for (i = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j) { |
| if (!this.attribs[i].isEqualNode(node.attribs[i])) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| return XMLElement; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 4361: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLNamedNodeMap; |
| |
| module.exports = XMLNamedNodeMap = (function() { |
| function XMLNamedNodeMap(nodes) { |
| this.nodes = nodes; |
| } |
| |
| Object.defineProperty(XMLNamedNodeMap.prototype, 'length', { |
| get: function() { |
| return Object.keys(this.nodes).length || 0; |
| } |
| }); |
| |
| XMLNamedNodeMap.prototype.clone = function() { |
| return this.nodes = null; |
| }; |
| |
| XMLNamedNodeMap.prototype.getNamedItem = function(name) { |
| return this.nodes[name]; |
| }; |
| |
| XMLNamedNodeMap.prototype.setNamedItem = function(node) { |
| var oldNode; |
| oldNode = this.nodes[node.nodeName]; |
| this.nodes[node.nodeName] = node; |
| return oldNode || null; |
| }; |
| |
| XMLNamedNodeMap.prototype.removeNamedItem = function(name) { |
| var oldNode; |
| oldNode = this.nodes[name]; |
| delete this.nodes[name]; |
| return oldNode || null; |
| }; |
| |
| XMLNamedNodeMap.prototype.item = function(index) { |
| return this.nodes[Object.keys(this.nodes)[index]] || null; |
| }; |
| |
| XMLNamedNodeMap.prototype.getNamedItemNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| XMLNamedNodeMap.prototype.setNamedItemNS = function(node) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| XMLNamedNodeMap.prototype.removeNamedItemNS = function(namespaceURI, localName) { |
| throw new Error("This DOM method is not implemented."); |
| }; |
| |
| return XMLNamedNodeMap; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 7608: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1, |
| hasProp = {}.hasOwnProperty; |
| |
| ref1 = __nccwpck_require__(8229), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue; |
| |
| XMLElement = null; |
| |
| XMLCData = null; |
| |
| XMLComment = null; |
| |
| XMLDeclaration = null; |
| |
| XMLDocType = null; |
| |
| XMLRaw = null; |
| |
| XMLText = null; |
| |
| XMLProcessingInstruction = null; |
| |
| XMLDummy = null; |
| |
| NodeType = null; |
| |
| XMLNodeList = null; |
| |
| XMLNamedNodeMap = null; |
| |
| DocumentPosition = null; |
| |
| module.exports = XMLNode = (function() { |
| function XMLNode(parent1) { |
| this.parent = parent1; |
| if (this.parent) { |
| this.options = this.parent.options; |
| this.stringify = this.parent.stringify; |
| } |
| this.value = null; |
| this.children = []; |
| this.baseURI = null; |
| if (!XMLElement) { |
| XMLElement = __nccwpck_require__(9437); |
| XMLCData = __nccwpck_require__(333); |
| XMLComment = __nccwpck_require__(4407); |
| XMLDeclaration = __nccwpck_require__(6364); |
| XMLDocType = __nccwpck_require__(1801); |
| XMLRaw = __nccwpck_require__(6329); |
| XMLText = __nccwpck_require__(1318); |
| XMLProcessingInstruction = __nccwpck_require__(6939); |
| XMLDummy = __nccwpck_require__(3590); |
| NodeType = __nccwpck_require__(9267); |
| XMLNodeList = __nccwpck_require__(6768); |
| XMLNamedNodeMap = __nccwpck_require__(4361); |
| DocumentPosition = __nccwpck_require__(2839); |
| } |
| } |
| |
| Object.defineProperty(XMLNode.prototype, 'nodeName', { |
| get: function() { |
| return this.name; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'nodeType', { |
| get: function() { |
| return this.type; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'nodeValue', { |
| get: function() { |
| return this.value; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'parentNode', { |
| get: function() { |
| return this.parent; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'childNodes', { |
| get: function() { |
| if (!this.childNodeList || !this.childNodeList.nodes) { |
| this.childNodeList = new XMLNodeList(this.children); |
| } |
| return this.childNodeList; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'firstChild', { |
| get: function() { |
| return this.children[0] || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'lastChild', { |
| get: function() { |
| return this.children[this.children.length - 1] || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'previousSibling', { |
| get: function() { |
| var i; |
| i = this.parent.children.indexOf(this); |
| return this.parent.children[i - 1] || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'nextSibling', { |
| get: function() { |
| var i; |
| i = this.parent.children.indexOf(this); |
| return this.parent.children[i + 1] || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'ownerDocument', { |
| get: function() { |
| return this.document() || null; |
| } |
| }); |
| |
| Object.defineProperty(XMLNode.prototype, 'textContent', { |
| get: function() { |
| var child, j, len, ref2, str; |
| if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) { |
| str = ''; |
| ref2 = this.children; |
| for (j = 0, len = ref2.length; j < len; j++) { |
| child = ref2[j]; |
| if (child.textContent) { |
| str += child.textContent; |
| } |
| } |
| return str; |
| } else { |
| return null; |
| } |
| }, |
| set: function(value) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| XMLNode.prototype.setParent = function(parent) { |
| var child, j, len, ref2, results; |
| this.parent = parent; |
| if (parent) { |
| this.options = parent.options; |
| this.stringify = parent.stringify; |
| } |
| ref2 = this.children; |
| results = []; |
| for (j = 0, len = ref2.length; j < len; j++) { |
| child = ref2[j]; |
| results.push(child.setParent(this)); |
| } |
| return results; |
| }; |
| |
| XMLNode.prototype.element = function(name, attributes, text) { |
| var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val; |
| lastChild = null; |
| if (attributes === null && (text == null)) { |
| ref2 = [{}, null], attributes = ref2[0], text = ref2[1]; |
| } |
| if (attributes == null) { |
| attributes = {}; |
| } |
| attributes = getValue(attributes); |
| if (!isObject(attributes)) { |
| ref3 = [attributes, text], text = ref3[0], attributes = ref3[1]; |
| } |
| if (name != null) { |
| name = getValue(name); |
| } |
| if (Array.isArray(name)) { |
| for (j = 0, len = name.length; j < len; j++) { |
| item = name[j]; |
| lastChild = this.element(item); |
| } |
| } else if (isFunction(name)) { |
| lastChild = this.element(name.apply()); |
| } else if (isObject(name)) { |
| for (key in name) { |
| if (!hasProp.call(name, key)) continue; |
| val = name[key]; |
| if (isFunction(val)) { |
| val = val.apply(); |
| } |
| if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) { |
| lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val); |
| } else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) { |
| lastChild = this.dummy(); |
| } else if (isObject(val) && isEmpty(val)) { |
| lastChild = this.element(key); |
| } else if (!this.options.keepNullNodes && (val == null)) { |
| lastChild = this.dummy(); |
| } else if (!this.options.separateArrayItems && Array.isArray(val)) { |
| for (k = 0, len1 = val.length; k < len1; k++) { |
| item = val[k]; |
| childNode = {}; |
| childNode[key] = item; |
| lastChild = this.element(childNode); |
| } |
| } else if (isObject(val)) { |
| if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) { |
| lastChild = this.element(val); |
| } else { |
| lastChild = this.element(key); |
| lastChild.element(val); |
| } |
| } else { |
| lastChild = this.element(key, val); |
| } |
| } |
| } else if (!this.options.keepNullNodes && text === null) { |
| lastChild = this.dummy(); |
| } else { |
| if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) { |
| lastChild = this.text(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) { |
| lastChild = this.cdata(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) { |
| lastChild = this.comment(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) { |
| lastChild = this.raw(text); |
| } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) { |
| lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text); |
| } else { |
| lastChild = this.node(name, attributes, text); |
| } |
| } |
| if (lastChild == null) { |
| throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo()); |
| } |
| return lastChild; |
| }; |
| |
| XMLNode.prototype.insertBefore = function(name, attributes, text) { |
| var child, i, newChild, refChild, removed; |
| if (name != null ? name.type : void 0) { |
| newChild = name; |
| refChild = attributes; |
| newChild.setParent(this); |
| if (refChild) { |
| i = children.indexOf(refChild); |
| removed = children.splice(i); |
| children.push(newChild); |
| Array.prototype.push.apply(children, removed); |
| } else { |
| children.push(newChild); |
| } |
| return newChild; |
| } else { |
| if (this.isRoot) { |
| throw new Error("Cannot insert elements at root level. " + this.debugInfo(name)); |
| } |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i); |
| child = this.parent.element(name, attributes, text); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return child; |
| } |
| }; |
| |
| XMLNode.prototype.insertAfter = function(name, attributes, text) { |
| var child, i, removed; |
| if (this.isRoot) { |
| throw new Error("Cannot insert elements at root level. " + this.debugInfo(name)); |
| } |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i + 1); |
| child = this.parent.element(name, attributes, text); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return child; |
| }; |
| |
| XMLNode.prototype.remove = function() { |
| var i, ref2; |
| if (this.isRoot) { |
| throw new Error("Cannot remove the root element. " + this.debugInfo()); |
| } |
| i = this.parent.children.indexOf(this); |
| [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref2 = [])), ref2; |
| return this.parent; |
| }; |
| |
| XMLNode.prototype.node = function(name, attributes, text) { |
| var child, ref2; |
| if (name != null) { |
| name = getValue(name); |
| } |
| attributes || (attributes = {}); |
| attributes = getValue(attributes); |
| if (!isObject(attributes)) { |
| ref2 = [attributes, text], text = ref2[0], attributes = ref2[1]; |
| } |
| child = new XMLElement(this, name, attributes); |
| if (text != null) { |
| child.text(text); |
| } |
| this.children.push(child); |
| return child; |
| }; |
| |
| XMLNode.prototype.text = function(value) { |
| var child; |
| if (isObject(value)) { |
| this.element(value); |
| } |
| child = new XMLText(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.cdata = function(value) { |
| var child; |
| child = new XMLCData(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.comment = function(value) { |
| var child; |
| child = new XMLComment(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.commentBefore = function(value) { |
| var child, i, removed; |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i); |
| child = this.parent.comment(value); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return this; |
| }; |
| |
| XMLNode.prototype.commentAfter = function(value) { |
| var child, i, removed; |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i + 1); |
| child = this.parent.comment(value); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return this; |
| }; |
| |
| XMLNode.prototype.raw = function(value) { |
| var child; |
| child = new XMLRaw(this, value); |
| this.children.push(child); |
| return this; |
| }; |
| |
| XMLNode.prototype.dummy = function() { |
| var child; |
| child = new XMLDummy(this); |
| return child; |
| }; |
| |
| XMLNode.prototype.instruction = function(target, value) { |
| var insTarget, insValue, instruction, j, len; |
| if (target != null) { |
| target = getValue(target); |
| } |
| if (value != null) { |
| value = getValue(value); |
| } |
| if (Array.isArray(target)) { |
| for (j = 0, len = target.length; j < len; j++) { |
| insTarget = target[j]; |
| this.instruction(insTarget); |
| } |
| } else if (isObject(target)) { |
| for (insTarget in target) { |
| if (!hasProp.call(target, insTarget)) continue; |
| insValue = target[insTarget]; |
| this.instruction(insTarget, insValue); |
| } |
| } else { |
| if (isFunction(value)) { |
| value = value.apply(); |
| } |
| instruction = new XMLProcessingInstruction(this, target, value); |
| this.children.push(instruction); |
| } |
| return this; |
| }; |
| |
| XMLNode.prototype.instructionBefore = function(target, value) { |
| var child, i, removed; |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i); |
| child = this.parent.instruction(target, value); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return this; |
| }; |
| |
| XMLNode.prototype.instructionAfter = function(target, value) { |
| var child, i, removed; |
| i = this.parent.children.indexOf(this); |
| removed = this.parent.children.splice(i + 1); |
| child = this.parent.instruction(target, value); |
| Array.prototype.push.apply(this.parent.children, removed); |
| return this; |
| }; |
| |
| XMLNode.prototype.declaration = function(version, encoding, standalone) { |
| var doc, xmldec; |
| doc = this.document(); |
| xmldec = new XMLDeclaration(doc, version, encoding, standalone); |
| if (doc.children.length === 0) { |
| doc.children.unshift(xmldec); |
| } else if (doc.children[0].type === NodeType.Declaration) { |
| doc.children[0] = xmldec; |
| } else { |
| doc.children.unshift(xmldec); |
| } |
| return doc.root() || doc; |
| }; |
| |
| XMLNode.prototype.dtd = function(pubID, sysID) { |
| var child, doc, doctype, i, j, k, len, len1, ref2, ref3; |
| doc = this.document(); |
| doctype = new XMLDocType(doc, pubID, sysID); |
| ref2 = doc.children; |
| for (i = j = 0, len = ref2.length; j < len; i = ++j) { |
| child = ref2[i]; |
| if (child.type === NodeType.DocType) { |
| doc.children[i] = doctype; |
| return doctype; |
| } |
| } |
| ref3 = doc.children; |
| for (i = k = 0, len1 = ref3.length; k < len1; i = ++k) { |
| child = ref3[i]; |
| if (child.isRoot) { |
| doc.children.splice(i, 0, doctype); |
| return doctype; |
| } |
| } |
| doc.children.push(doctype); |
| return doctype; |
| }; |
| |
| XMLNode.prototype.up = function() { |
| if (this.isRoot) { |
| throw new Error("The root node has no parent. Use doc() if you need to get the document object."); |
| } |
| return this.parent; |
| }; |
| |
| XMLNode.prototype.root = function() { |
| var node; |
| node = this; |
| while (node) { |
| if (node.type === NodeType.Document) { |
| return node.rootObject; |
| } else if (node.isRoot) { |
| return node; |
| } else { |
| node = node.parent; |
| } |
| } |
| }; |
| |
| XMLNode.prototype.document = function() { |
| var node; |
| node = this; |
| while (node) { |
| if (node.type === NodeType.Document) { |
| return node; |
| } else { |
| node = node.parent; |
| } |
| } |
| }; |
| |
| XMLNode.prototype.end = function(options) { |
| return this.document().end(options); |
| }; |
| |
| XMLNode.prototype.prev = function() { |
| var i; |
| i = this.parent.children.indexOf(this); |
| if (i < 1) { |
| throw new Error("Already at the first node. " + this.debugInfo()); |
| } |
| return this.parent.children[i - 1]; |
| }; |
| |
| XMLNode.prototype.next = function() { |
| var i; |
| i = this.parent.children.indexOf(this); |
| if (i === -1 || i === this.parent.children.length - 1) { |
| throw new Error("Already at the last node. " + this.debugInfo()); |
| } |
| return this.parent.children[i + 1]; |
| }; |
| |
| XMLNode.prototype.importDocument = function(doc) { |
| var clonedRoot; |
| clonedRoot = doc.root().clone(); |
| clonedRoot.parent = this; |
| clonedRoot.isRoot = false; |
| this.children.push(clonedRoot); |
| return this; |
| }; |
| |
| XMLNode.prototype.debugInfo = function(name) { |
| var ref2, ref3; |
| name = name || this.name; |
| if ((name == null) && !((ref2 = this.parent) != null ? ref2.name : void 0)) { |
| return ""; |
| } else if (name == null) { |
| return "parent: <" + this.parent.name + ">"; |
| } else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) { |
| return "node: <" + name + ">"; |
| } else { |
| return "node: <" + name + ">, parent: <" + this.parent.name + ">"; |
| } |
| }; |
| |
| XMLNode.prototype.ele = function(name, attributes, text) { |
| return this.element(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.nod = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.txt = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLNode.prototype.dat = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLNode.prototype.com = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLNode.prototype.ins = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLNode.prototype.doc = function() { |
| return this.document(); |
| }; |
| |
| XMLNode.prototype.dec = function(version, encoding, standalone) { |
| return this.declaration(version, encoding, standalone); |
| }; |
| |
| XMLNode.prototype.e = function(name, attributes, text) { |
| return this.element(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.n = function(name, attributes, text) { |
| return this.node(name, attributes, text); |
| }; |
| |
| XMLNode.prototype.t = function(value) { |
| return this.text(value); |
| }; |
| |
| XMLNode.prototype.d = function(value) { |
| return this.cdata(value); |
| }; |
| |
| XMLNode.prototype.c = function(value) { |
| return this.comment(value); |
| }; |
| |
| XMLNode.prototype.r = function(value) { |
| return this.raw(value); |
| }; |
| |
| XMLNode.prototype.i = function(target, value) { |
| return this.instruction(target, value); |
| }; |
| |
| XMLNode.prototype.u = function() { |
| return this.up(); |
| }; |
| |
| XMLNode.prototype.importXMLBuilder = function(doc) { |
| return this.importDocument(doc); |
| }; |
| |
| XMLNode.prototype.replaceChild = function(newChild, oldChild) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.removeChild = function(oldChild) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.appendChild = function(newChild) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.hasChildNodes = function() { |
| return this.children.length !== 0; |
| }; |
| |
| XMLNode.prototype.cloneNode = function(deep) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.normalize = function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.isSupported = function(feature, version) { |
| return true; |
| }; |
| |
| XMLNode.prototype.hasAttributes = function() { |
| return this.attribs.length !== 0; |
| }; |
| |
| XMLNode.prototype.compareDocumentPosition = function(other) { |
| var ref, res; |
| ref = this; |
| if (ref === other) { |
| return 0; |
| } else if (this.document() !== other.document()) { |
| res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific; |
| if (Math.random() < 0.5) { |
| res |= DocumentPosition.Preceding; |
| } else { |
| res |= DocumentPosition.Following; |
| } |
| return res; |
| } else if (ref.isAncestor(other)) { |
| return DocumentPosition.Contains | DocumentPosition.Preceding; |
| } else if (ref.isDescendant(other)) { |
| return DocumentPosition.Contains | DocumentPosition.Following; |
| } else if (ref.isPreceding(other)) { |
| return DocumentPosition.Preceding; |
| } else { |
| return DocumentPosition.Following; |
| } |
| }; |
| |
| XMLNode.prototype.isSameNode = function(other) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.lookupPrefix = function(namespaceURI) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.isDefaultNamespace = function(namespaceURI) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.lookupNamespaceURI = function(prefix) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.isEqualNode = function(node) { |
| var i, j, ref2; |
| if (node.nodeType !== this.nodeType) { |
| return false; |
| } |
| if (node.children.length !== this.children.length) { |
| return false; |
| } |
| for (i = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i = 0 <= ref2 ? ++j : --j) { |
| if (!this.children[i].isEqualNode(node.children[i])) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| XMLNode.prototype.getFeature = function(feature, version) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.setUserData = function(key, data, handler) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.getUserData = function(key) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLNode.prototype.contains = function(other) { |
| if (!other) { |
| return false; |
| } |
| return other === this || this.isDescendant(other); |
| }; |
| |
| XMLNode.prototype.isDescendant = function(node) { |
| var child, isDescendantChild, j, len, ref2; |
| ref2 = this.children; |
| for (j = 0, len = ref2.length; j < len; j++) { |
| child = ref2[j]; |
| if (node === child) { |
| return true; |
| } |
| isDescendantChild = child.isDescendant(node); |
| if (isDescendantChild) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| XMLNode.prototype.isAncestor = function(node) { |
| return node.isDescendant(this); |
| }; |
| |
| XMLNode.prototype.isPreceding = function(node) { |
| var nodePos, thisPos; |
| nodePos = this.treePosition(node); |
| thisPos = this.treePosition(this); |
| if (nodePos === -1 || thisPos === -1) { |
| return false; |
| } else { |
| return nodePos < thisPos; |
| } |
| }; |
| |
| XMLNode.prototype.isFollowing = function(node) { |
| var nodePos, thisPos; |
| nodePos = this.treePosition(node); |
| thisPos = this.treePosition(this); |
| if (nodePos === -1 || thisPos === -1) { |
| return false; |
| } else { |
| return nodePos > thisPos; |
| } |
| }; |
| |
| XMLNode.prototype.treePosition = function(node) { |
| var found, pos; |
| pos = 0; |
| found = false; |
| this.foreachTreeNode(this.document(), function(childNode) { |
| pos++; |
| if (!found && childNode === node) { |
| return found = true; |
| } |
| }); |
| if (found) { |
| return pos; |
| } else { |
| return -1; |
| } |
| }; |
| |
| XMLNode.prototype.foreachTreeNode = function(node, func) { |
| var child, j, len, ref2, res; |
| node || (node = this.document()); |
| ref2 = node.children; |
| for (j = 0, len = ref2.length; j < len; j++) { |
| child = ref2[j]; |
| if (res = func(child)) { |
| return res; |
| } else { |
| res = this.foreachTreeNode(child, func); |
| if (res) { |
| return res; |
| } |
| } |
| } |
| }; |
| |
| return XMLNode; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6768: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLNodeList; |
| |
| module.exports = XMLNodeList = (function() { |
| function XMLNodeList(nodes) { |
| this.nodes = nodes; |
| } |
| |
| Object.defineProperty(XMLNodeList.prototype, 'length', { |
| get: function() { |
| return this.nodes.length || 0; |
| } |
| }); |
| |
| XMLNodeList.prototype.clone = function() { |
| return this.nodes = null; |
| }; |
| |
| XMLNodeList.prototype.item = function(index) { |
| return this.nodes[index] || null; |
| }; |
| |
| return XMLNodeList; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6939: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLCharacterData, XMLProcessingInstruction, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLCharacterData = __nccwpck_require__(7709); |
| |
| module.exports = XMLProcessingInstruction = (function(superClass) { |
| extend(XMLProcessingInstruction, superClass); |
| |
| function XMLProcessingInstruction(parent, target, value) { |
| XMLProcessingInstruction.__super__.constructor.call(this, parent); |
| if (target == null) { |
| throw new Error("Missing instruction target. " + this.debugInfo()); |
| } |
| this.type = NodeType.ProcessingInstruction; |
| this.target = this.stringify.insTarget(target); |
| this.name = this.target; |
| if (value) { |
| this.value = this.stringify.insValue(value); |
| } |
| } |
| |
| XMLProcessingInstruction.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLProcessingInstruction.prototype.toString = function(options) { |
| return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLProcessingInstruction.prototype.isEqualNode = function(node) { |
| if (!XMLProcessingInstruction.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) { |
| return false; |
| } |
| if (node.target !== this.target) { |
| return false; |
| } |
| return true; |
| }; |
| |
| return XMLProcessingInstruction; |
| |
| })(XMLCharacterData); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6329: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLNode, XMLRaw, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLNode = __nccwpck_require__(7608); |
| |
| module.exports = XMLRaw = (function(superClass) { |
| extend(XMLRaw, superClass); |
| |
| function XMLRaw(parent, text) { |
| XMLRaw.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing raw text. " + this.debugInfo()); |
| } |
| this.type = NodeType.Raw; |
| this.value = this.stringify.raw(text); |
| } |
| |
| XMLRaw.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLRaw.prototype.toString = function(options) { |
| return this.options.writer.raw(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| return XMLRaw; |
| |
| })(XMLNode); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 8601: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, WriterState, XMLStreamWriter, XMLWriterBase, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLWriterBase = __nccwpck_require__(6752); |
| |
| WriterState = __nccwpck_require__(9766); |
| |
| module.exports = XMLStreamWriter = (function(superClass) { |
| extend(XMLStreamWriter, superClass); |
| |
| function XMLStreamWriter(stream, options) { |
| this.stream = stream; |
| XMLStreamWriter.__super__.constructor.call(this, options); |
| } |
| |
| XMLStreamWriter.prototype.endline = function(node, options, level) { |
| if (node.isLastRootNode && options.state === WriterState.CloseTag) { |
| return ''; |
| } else { |
| return XMLStreamWriter.__super__.endline.call(this, node, options, level); |
| } |
| }; |
| |
| XMLStreamWriter.prototype.document = function(doc, options) { |
| var child, i, j, k, len, len1, ref, ref1, results; |
| ref = doc.children; |
| for (i = j = 0, len = ref.length; j < len; i = ++j) { |
| child = ref[i]; |
| child.isLastRootNode = i === doc.children.length - 1; |
| } |
| options = this.filterOptions(options); |
| ref1 = doc.children; |
| results = []; |
| for (k = 0, len1 = ref1.length; k < len1; k++) { |
| child = ref1[k]; |
| results.push(this.writeChildNode(child, options, 0)); |
| } |
| return results; |
| }; |
| |
| XMLStreamWriter.prototype.attribute = function(att, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.attribute.call(this, att, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.cdata = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.cdata.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.comment = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.comment.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.declaration = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.declaration.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.docType = function(node, options, level) { |
| var child, j, len, ref; |
| level || (level = 0); |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| this.stream.write(this.indent(node, options, level)); |
| this.stream.write('<!DOCTYPE ' + node.root().name); |
| if (node.pubID && node.sysID) { |
| this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"'); |
| } else if (node.sysID) { |
| this.stream.write(' SYSTEM "' + node.sysID + '"'); |
| } |
| if (node.children.length > 0) { |
| this.stream.write(' ['); |
| this.stream.write(this.endline(node, options, level)); |
| options.state = WriterState.InsideTag; |
| ref = node.children; |
| for (j = 0, len = ref.length; j < len; j++) { |
| child = ref[j]; |
| this.writeChildNode(child, options, level + 1); |
| } |
| options.state = WriterState.CloseTag; |
| this.stream.write(']'); |
| } |
| options.state = WriterState.CloseTag; |
| this.stream.write(options.spaceBeforeSlash + '>'); |
| this.stream.write(this.endline(node, options, level)); |
| options.state = WriterState.None; |
| return this.closeNode(node, options, level); |
| }; |
| |
| XMLStreamWriter.prototype.element = function(node, options, level) { |
| var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1; |
| level || (level = 0); |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| this.stream.write(this.indent(node, options, level) + '<' + node.name); |
| ref = node.attribs; |
| for (name in ref) { |
| if (!hasProp.call(ref, name)) continue; |
| att = ref[name]; |
| this.attribute(att, options, level); |
| } |
| childNodeCount = node.children.length; |
| firstChildNode = childNodeCount === 0 ? null : node.children[0]; |
| if (childNodeCount === 0 || node.children.every(function(e) { |
| return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === ''; |
| })) { |
| if (options.allowEmpty) { |
| this.stream.write('>'); |
| options.state = WriterState.CloseTag; |
| this.stream.write('</' + node.name + '>'); |
| } else { |
| options.state = WriterState.CloseTag; |
| this.stream.write(options.spaceBeforeSlash + '/>'); |
| } |
| } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) { |
| this.stream.write('>'); |
| options.state = WriterState.InsideTag; |
| options.suppressPrettyCount++; |
| prettySuppressed = true; |
| this.writeChildNode(firstChildNode, options, level + 1); |
| options.suppressPrettyCount--; |
| prettySuppressed = false; |
| options.state = WriterState.CloseTag; |
| this.stream.write('</' + node.name + '>'); |
| } else { |
| this.stream.write('>' + this.endline(node, options, level)); |
| options.state = WriterState.InsideTag; |
| ref1 = node.children; |
| for (j = 0, len = ref1.length; j < len; j++) { |
| child = ref1[j]; |
| this.writeChildNode(child, options, level + 1); |
| } |
| options.state = WriterState.CloseTag; |
| this.stream.write(this.indent(node, options, level) + '</' + node.name + '>'); |
| } |
| this.stream.write(this.endline(node, options, level)); |
| options.state = WriterState.None; |
| return this.closeNode(node, options, level); |
| }; |
| |
| XMLStreamWriter.prototype.processingInstruction = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.processingInstruction.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.raw = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.raw.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.text = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.text.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.dtdAttList = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.dtdAttList.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.dtdElement = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.dtdElement.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.dtdEntity = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.dtdEntity.call(this, node, options, level)); |
| }; |
| |
| XMLStreamWriter.prototype.dtdNotation = function(node, options, level) { |
| return this.stream.write(XMLStreamWriter.__super__.dtdNotation.call(this, node, options, level)); |
| }; |
| |
| return XMLStreamWriter; |
| |
| })(XMLWriterBase); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 5913: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLStringWriter, XMLWriterBase, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| XMLWriterBase = __nccwpck_require__(6752); |
| |
| module.exports = XMLStringWriter = (function(superClass) { |
| extend(XMLStringWriter, superClass); |
| |
| function XMLStringWriter(options) { |
| XMLStringWriter.__super__.constructor.call(this, options); |
| } |
| |
| XMLStringWriter.prototype.document = function(doc, options) { |
| var child, i, len, r, ref; |
| options = this.filterOptions(options); |
| r = ''; |
| ref = doc.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| r += this.writeChildNode(child, options, 0); |
| } |
| if (options.pretty && r.slice(-options.newline.length) === options.newline) { |
| r = r.slice(0, -options.newline.length); |
| } |
| return r; |
| }; |
| |
| return XMLStringWriter; |
| |
| })(XMLWriterBase); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 8594: |
| /***/ (function(module) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var XMLStringifier, |
| bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, |
| hasProp = {}.hasOwnProperty; |
| |
| module.exports = XMLStringifier = (function() { |
| function XMLStringifier(options) { |
| this.assertLegalName = bind(this.assertLegalName, this); |
| this.assertLegalChar = bind(this.assertLegalChar, this); |
| var key, ref, value; |
| options || (options = {}); |
| this.options = options; |
| if (!this.options.version) { |
| this.options.version = '1.0'; |
| } |
| ref = options.stringify || {}; |
| for (key in ref) { |
| if (!hasProp.call(ref, key)) continue; |
| value = ref[key]; |
| this[key] = value; |
| } |
| } |
| |
| XMLStringifier.prototype.name = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalName('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.text = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar(this.textEscape('' + val || '')); |
| }; |
| |
| XMLStringifier.prototype.cdata = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| val = '' + val || ''; |
| val = val.replace(']]>', ']]]]><![CDATA[>'); |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.comment = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| val = '' + val || ''; |
| if (val.match(/--/)) { |
| throw new Error("Comment text cannot contain double-hypen: " + val); |
| } |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.raw = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return '' + val || ''; |
| }; |
| |
| XMLStringifier.prototype.attValue = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar(this.attEscape(val = '' + val || '')); |
| }; |
| |
| XMLStringifier.prototype.insTarget = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.insValue = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| val = '' + val || ''; |
| if (val.match(/\?>/)) { |
| throw new Error("Invalid processing instruction value: " + val); |
| } |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.xmlVersion = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| val = '' + val || ''; |
| if (!val.match(/1\.[0-9]+/)) { |
| throw new Error("Invalid version number: " + val); |
| } |
| return val; |
| }; |
| |
| XMLStringifier.prototype.xmlEncoding = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| val = '' + val || ''; |
| if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) { |
| throw new Error("Invalid encoding: " + val); |
| } |
| return this.assertLegalChar(val); |
| }; |
| |
| XMLStringifier.prototype.xmlStandalone = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| if (val) { |
| return "yes"; |
| } else { |
| return "no"; |
| } |
| }; |
| |
| XMLStringifier.prototype.dtdPubID = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdSysID = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdElementValue = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdAttType = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdAttDefault = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdEntityValue = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.dtdNData = function(val) { |
| if (this.options.noValidation) { |
| return val; |
| } |
| return this.assertLegalChar('' + val || ''); |
| }; |
| |
| XMLStringifier.prototype.convertAttKey = '@'; |
| |
| XMLStringifier.prototype.convertPIKey = '?'; |
| |
| XMLStringifier.prototype.convertTextKey = '#text'; |
| |
| XMLStringifier.prototype.convertCDataKey = '#cdata'; |
| |
| XMLStringifier.prototype.convertCommentKey = '#comment'; |
| |
| XMLStringifier.prototype.convertRawKey = '#raw'; |
| |
| XMLStringifier.prototype.assertLegalChar = function(str) { |
| var regex, res; |
| if (this.options.noValidation) { |
| return str; |
| } |
| regex = ''; |
| if (this.options.version === '1.0') { |
| regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; |
| if (res = str.match(regex)) { |
| throw new Error("Invalid character in string: " + str + " at index " + res.index); |
| } |
| } else if (this.options.version === '1.1') { |
| regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; |
| if (res = str.match(regex)) { |
| throw new Error("Invalid character in string: " + str + " at index " + res.index); |
| } |
| } |
| return str; |
| }; |
| |
| XMLStringifier.prototype.assertLegalName = function(str) { |
| var regex; |
| if (this.options.noValidation) { |
| return str; |
| } |
| this.assertLegalChar(str); |
| regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/; |
| if (!str.match(regex)) { |
| throw new Error("Invalid character in name"); |
| } |
| return str; |
| }; |
| |
| XMLStringifier.prototype.textEscape = function(str) { |
| var ampregex; |
| if (this.options.noValidation) { |
| return str; |
| } |
| ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g; |
| return str.replace(ampregex, '&').replace(/</g, '<').replace(/>/g, '>').replace(/\r/g, '
'); |
| }; |
| |
| XMLStringifier.prototype.attEscape = function(str) { |
| var ampregex; |
| if (this.options.noValidation) { |
| return str; |
| } |
| ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g; |
| return str.replace(ampregex, '&').replace(/</g, '<').replace(/"/g, '"').replace(/\t/g, '	').replace(/\n/g, '
').replace(/\r/g, '
'); |
| }; |
| |
| return XMLStringifier; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 1318: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, XMLCharacterData, XMLText, |
| extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, |
| hasProp = {}.hasOwnProperty; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLCharacterData = __nccwpck_require__(7709); |
| |
| module.exports = XMLText = (function(superClass) { |
| extend(XMLText, superClass); |
| |
| function XMLText(parent, text) { |
| XMLText.__super__.constructor.call(this, parent); |
| if (text == null) { |
| throw new Error("Missing element text. " + this.debugInfo()); |
| } |
| this.name = "#text"; |
| this.type = NodeType.Text; |
| this.value = this.stringify.text(text); |
| } |
| |
| Object.defineProperty(XMLText.prototype, 'isElementContentWhitespace', { |
| get: function() { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| } |
| }); |
| |
| Object.defineProperty(XMLText.prototype, 'wholeText', { |
| get: function() { |
| var next, prev, str; |
| str = ''; |
| prev = this.previousSibling; |
| while (prev) { |
| str = prev.data + str; |
| prev = prev.previousSibling; |
| } |
| str += this.data; |
| next = this.nextSibling; |
| while (next) { |
| str = str + next.data; |
| next = next.nextSibling; |
| } |
| return str; |
| } |
| }); |
| |
| XMLText.prototype.clone = function() { |
| return Object.create(this); |
| }; |
| |
| XMLText.prototype.toString = function(options) { |
| return this.options.writer.text(this, this.options.writer.filterOptions(options)); |
| }; |
| |
| XMLText.prototype.splitText = function(offset) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| XMLText.prototype.replaceWholeText = function(content) { |
| throw new Error("This DOM method is not implemented." + this.debugInfo()); |
| }; |
| |
| return XMLText; |
| |
| })(XMLCharacterData); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 6752: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign, |
| hasProp = {}.hasOwnProperty; |
| |
| assign = __nccwpck_require__(8229).assign; |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| XMLDeclaration = __nccwpck_require__(6364); |
| |
| XMLDocType = __nccwpck_require__(1801); |
| |
| XMLCData = __nccwpck_require__(333); |
| |
| XMLComment = __nccwpck_require__(4407); |
| |
| XMLElement = __nccwpck_require__(9437); |
| |
| XMLRaw = __nccwpck_require__(6329); |
| |
| XMLText = __nccwpck_require__(1318); |
| |
| XMLProcessingInstruction = __nccwpck_require__(6939); |
| |
| XMLDummy = __nccwpck_require__(3590); |
| |
| XMLDTDAttList = __nccwpck_require__(1015); |
| |
| XMLDTDElement = __nccwpck_require__(2421); |
| |
| XMLDTDEntity = __nccwpck_require__(53); |
| |
| XMLDTDNotation = __nccwpck_require__(2837); |
| |
| WriterState = __nccwpck_require__(9766); |
| |
| module.exports = XMLWriterBase = (function() { |
| function XMLWriterBase(options) { |
| var key, ref, value; |
| options || (options = {}); |
| this.options = options; |
| ref = options.writer || {}; |
| for (key in ref) { |
| if (!hasProp.call(ref, key)) continue; |
| value = ref[key]; |
| this["_" + key] = this[key]; |
| this[key] = value; |
| } |
| } |
| |
| XMLWriterBase.prototype.filterOptions = function(options) { |
| var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6; |
| options || (options = {}); |
| options = assign({}, this.options, options); |
| filteredOptions = { |
| writer: this |
| }; |
| filteredOptions.pretty = options.pretty || false; |
| filteredOptions.allowEmpty = options.allowEmpty || false; |
| filteredOptions.indent = (ref = options.indent) != null ? ref : ' '; |
| filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\n'; |
| filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0; |
| filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0; |
| filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : ''; |
| if (filteredOptions.spaceBeforeSlash === true) { |
| filteredOptions.spaceBeforeSlash = ' '; |
| } |
| filteredOptions.suppressPrettyCount = 0; |
| filteredOptions.user = {}; |
| filteredOptions.state = WriterState.None; |
| return filteredOptions; |
| }; |
| |
| XMLWriterBase.prototype.indent = function(node, options, level) { |
| var indentLevel; |
| if (!options.pretty || options.suppressPrettyCount) { |
| return ''; |
| } else if (options.pretty) { |
| indentLevel = (level || 0) + options.offset + 1; |
| if (indentLevel > 0) { |
| return new Array(indentLevel).join(options.indent); |
| } |
| } |
| return ''; |
| }; |
| |
| XMLWriterBase.prototype.endline = function(node, options, level) { |
| if (!options.pretty || options.suppressPrettyCount) { |
| return ''; |
| } else { |
| return options.newline; |
| } |
| }; |
| |
| XMLWriterBase.prototype.attribute = function(att, options, level) { |
| var r; |
| this.openAttribute(att, options, level); |
| r = ' ' + att.name + '="' + att.value + '"'; |
| this.closeAttribute(att, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.cdata = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<![CDATA['; |
| options.state = WriterState.InsideTag; |
| r += node.value; |
| options.state = WriterState.CloseTag; |
| r += ']]>' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.comment = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<!-- '; |
| options.state = WriterState.InsideTag; |
| r += node.value; |
| options.state = WriterState.CloseTag; |
| r += ' -->' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.declaration = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<?xml'; |
| options.state = WriterState.InsideTag; |
| r += ' version="' + node.version + '"'; |
| if (node.encoding != null) { |
| r += ' encoding="' + node.encoding + '"'; |
| } |
| if (node.standalone != null) { |
| r += ' standalone="' + node.standalone + '"'; |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '?>'; |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.docType = function(node, options, level) { |
| var child, i, len, r, ref; |
| level || (level = 0); |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level); |
| r += '<!DOCTYPE ' + node.root().name; |
| if (node.pubID && node.sysID) { |
| r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"'; |
| } else if (node.sysID) { |
| r += ' SYSTEM "' + node.sysID + '"'; |
| } |
| if (node.children.length > 0) { |
| r += ' ['; |
| r += this.endline(node, options, level); |
| options.state = WriterState.InsideTag; |
| ref = node.children; |
| for (i = 0, len = ref.length; i < len; i++) { |
| child = ref[i]; |
| r += this.writeChildNode(child, options, level + 1); |
| } |
| options.state = WriterState.CloseTag; |
| r += ']'; |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '>'; |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.element = function(node, options, level) { |
| var att, child, childNodeCount, firstChildNode, i, j, len, len1, name, prettySuppressed, r, ref, ref1, ref2; |
| level || (level = 0); |
| prettySuppressed = false; |
| r = ''; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r += this.indent(node, options, level) + '<' + node.name; |
| ref = node.attribs; |
| for (name in ref) { |
| if (!hasProp.call(ref, name)) continue; |
| att = ref[name]; |
| r += this.attribute(att, options, level); |
| } |
| childNodeCount = node.children.length; |
| firstChildNode = childNodeCount === 0 ? null : node.children[0]; |
| if (childNodeCount === 0 || node.children.every(function(e) { |
| return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === ''; |
| })) { |
| if (options.allowEmpty) { |
| r += '>'; |
| options.state = WriterState.CloseTag; |
| r += '</' + node.name + '>' + this.endline(node, options, level); |
| } else { |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level); |
| } |
| } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) { |
| r += '>'; |
| options.state = WriterState.InsideTag; |
| options.suppressPrettyCount++; |
| prettySuppressed = true; |
| r += this.writeChildNode(firstChildNode, options, level + 1); |
| options.suppressPrettyCount--; |
| prettySuppressed = false; |
| options.state = WriterState.CloseTag; |
| r += '</' + node.name + '>' + this.endline(node, options, level); |
| } else { |
| if (options.dontPrettyTextNodes) { |
| ref1 = node.children; |
| for (i = 0, len = ref1.length; i < len; i++) { |
| child = ref1[i]; |
| if ((child.type === NodeType.Text || child.type === NodeType.Raw) && (child.value != null)) { |
| options.suppressPrettyCount++; |
| prettySuppressed = true; |
| break; |
| } |
| } |
| } |
| r += '>' + this.endline(node, options, level); |
| options.state = WriterState.InsideTag; |
| ref2 = node.children; |
| for (j = 0, len1 = ref2.length; j < len1; j++) { |
| child = ref2[j]; |
| r += this.writeChildNode(child, options, level + 1); |
| } |
| options.state = WriterState.CloseTag; |
| r += this.indent(node, options, level) + '</' + node.name + '>'; |
| if (prettySuppressed) { |
| options.suppressPrettyCount--; |
| } |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| } |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.writeChildNode = function(node, options, level) { |
| switch (node.type) { |
| case NodeType.CData: |
| return this.cdata(node, options, level); |
| case NodeType.Comment: |
| return this.comment(node, options, level); |
| case NodeType.Element: |
| return this.element(node, options, level); |
| case NodeType.Raw: |
| return this.raw(node, options, level); |
| case NodeType.Text: |
| return this.text(node, options, level); |
| case NodeType.ProcessingInstruction: |
| return this.processingInstruction(node, options, level); |
| case NodeType.Dummy: |
| return ''; |
| case NodeType.Declaration: |
| return this.declaration(node, options, level); |
| case NodeType.DocType: |
| return this.docType(node, options, level); |
| case NodeType.AttributeDeclaration: |
| return this.dtdAttList(node, options, level); |
| case NodeType.ElementDeclaration: |
| return this.dtdElement(node, options, level); |
| case NodeType.EntityDeclaration: |
| return this.dtdEntity(node, options, level); |
| case NodeType.NotationDeclaration: |
| return this.dtdNotation(node, options, level); |
| default: |
| throw new Error("Unknown XML node type: " + node.constructor.name); |
| } |
| }; |
| |
| XMLWriterBase.prototype.processingInstruction = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<?'; |
| options.state = WriterState.InsideTag; |
| r += node.target; |
| if (node.value) { |
| r += ' ' + node.value; |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '?>'; |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.raw = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level); |
| options.state = WriterState.InsideTag; |
| r += node.value; |
| options.state = WriterState.CloseTag; |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.text = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level); |
| options.state = WriterState.InsideTag; |
| r += node.value; |
| options.state = WriterState.CloseTag; |
| r += this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.dtdAttList = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<!ATTLIST'; |
| options.state = WriterState.InsideTag; |
| r += ' ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType; |
| if (node.defaultValueType !== '#DEFAULT') { |
| r += ' ' + node.defaultValueType; |
| } |
| if (node.defaultValue) { |
| r += ' "' + node.defaultValue + '"'; |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '>' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.dtdElement = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<!ELEMENT'; |
| options.state = WriterState.InsideTag; |
| r += ' ' + node.name + ' ' + node.value; |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '>' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.dtdEntity = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<!ENTITY'; |
| options.state = WriterState.InsideTag; |
| if (node.pe) { |
| r += ' %'; |
| } |
| r += ' ' + node.name; |
| if (node.value) { |
| r += ' "' + node.value + '"'; |
| } else { |
| if (node.pubID && node.sysID) { |
| r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"'; |
| } else if (node.sysID) { |
| r += ' SYSTEM "' + node.sysID + '"'; |
| } |
| if (node.nData) { |
| r += ' NDATA ' + node.nData; |
| } |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '>' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.dtdNotation = function(node, options, level) { |
| var r; |
| this.openNode(node, options, level); |
| options.state = WriterState.OpenTag; |
| r = this.indent(node, options, level) + '<!NOTATION'; |
| options.state = WriterState.InsideTag; |
| r += ' ' + node.name; |
| if (node.pubID && node.sysID) { |
| r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"'; |
| } else if (node.pubID) { |
| r += ' PUBLIC "' + node.pubID + '"'; |
| } else if (node.sysID) { |
| r += ' SYSTEM "' + node.sysID + '"'; |
| } |
| options.state = WriterState.CloseTag; |
| r += options.spaceBeforeSlash + '>' + this.endline(node, options, level); |
| options.state = WriterState.None; |
| this.closeNode(node, options, level); |
| return r; |
| }; |
| |
| XMLWriterBase.prototype.openNode = function(node, options, level) {}; |
| |
| XMLWriterBase.prototype.closeNode = function(node, options, level) {}; |
| |
| XMLWriterBase.prototype.openAttribute = function(att, options, level) {}; |
| |
| XMLWriterBase.prototype.closeAttribute = function(att, options, level) {}; |
| |
| return XMLWriterBase; |
| |
| })(); |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 2958: |
| /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) { |
| |
| // Generated by CoffeeScript 1.12.7 |
| (function() { |
| var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref; |
| |
| ref = __nccwpck_require__(8229), assign = ref.assign, isFunction = ref.isFunction; |
| |
| XMLDOMImplementation = __nccwpck_require__(8310); |
| |
| XMLDocument = __nccwpck_require__(3730); |
| |
| XMLDocumentCB = __nccwpck_require__(7356); |
| |
| XMLStringWriter = __nccwpck_require__(5913); |
| |
| XMLStreamWriter = __nccwpck_require__(8601); |
| |
| NodeType = __nccwpck_require__(9267); |
| |
| WriterState = __nccwpck_require__(9766); |
| |
| module.exports.create = function(name, xmldec, doctype, options) { |
| var doc, root; |
| if (name == null) { |
| throw new Error("Root element needs a name."); |
| } |
| options = assign({}, xmldec, doctype, options); |
| doc = new XMLDocument(options); |
| root = doc.element(name); |
| if (!options.headless) { |
| doc.declaration(options); |
| if ((options.pubID != null) || (options.sysID != null)) { |
| doc.dtd(options); |
| } |
| } |
| return root; |
| }; |
| |
| module.exports.begin = function(options, onData, onEnd) { |
| var ref1; |
| if (isFunction(options)) { |
| ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1]; |
| options = {}; |
| } |
| if (onData) { |
| return new XMLDocumentCB(options, onData, onEnd); |
| } else { |
| return new XMLDocument(options); |
| } |
| }; |
| |
| module.exports.stringWriter = function(options) { |
| return new XMLStringWriter(options); |
| }; |
| |
| module.exports.streamWriter = function(stream, options) { |
| return new XMLStreamWriter(stream, options); |
| }; |
| |
| module.exports.implementation = new XMLDOMImplementation(); |
| |
| module.exports.nodeType = NodeType; |
| |
| module.exports.writerState = WriterState; |
| |
| }).call(this); |
| |
| |
| /***/ }), |
| |
| /***/ 2877: |
| /***/ ((module) => { |
| |
| module.exports = eval("require")("encoding"); |
| |
| |
| /***/ }), |
| |
| /***/ 2941: |
| /***/ ((module) => { |
| |
| module.exports = eval("require")("original-fs"); |
| |
| |
| /***/ }), |
| |
| /***/ 2357: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("assert");; |
| |
| /***/ }), |
| |
| /***/ 4293: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("buffer");; |
| |
| /***/ }), |
| |
| /***/ 3129: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("child_process");; |
| |
| /***/ }), |
| |
| /***/ 881: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("dns");; |
| |
| /***/ }), |
| |
| /***/ 8614: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("events");; |
| |
| /***/ }), |
| |
| /***/ 5747: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("fs");; |
| |
| /***/ }), |
| |
| /***/ 8605: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("http");; |
| |
| /***/ }), |
| |
| /***/ 7565: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("http2");; |
| |
| /***/ }), |
| |
| /***/ 7211: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("https");; |
| |
| /***/ }), |
| |
| /***/ 1631: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("net");; |
| |
| /***/ }), |
| |
| /***/ 2087: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("os");; |
| |
| /***/ }), |
| |
| /***/ 5622: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("path");; |
| |
| /***/ }), |
| |
| /***/ 2413: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("stream");; |
| |
| /***/ }), |
| |
| /***/ 4304: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("string_decoder");; |
| |
| /***/ }), |
| |
| /***/ 8213: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("timers");; |
| |
| /***/ }), |
| |
| /***/ 4016: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("tls");; |
| |
| /***/ }), |
| |
| /***/ 8835: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("url");; |
| |
| /***/ }), |
| |
| /***/ 1669: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("util");; |
| |
| /***/ }), |
| |
| /***/ 8761: |
| /***/ ((module) => { |
| |
| "use strict"; |
| module.exports = require("zlib");; |
| |
| /***/ }) |
| |
| /******/ }); |
| /************************************************************************/ |
| /******/ // The module cache |
| /******/ var __webpack_module_cache__ = {}; |
| /******/ |
| /******/ // The require function |
| /******/ function __nccwpck_require__(moduleId) { |
| /******/ // Check if module is in cache |
| /******/ if(__webpack_module_cache__[moduleId]) { |
| /******/ return __webpack_module_cache__[moduleId].exports; |
| /******/ } |
| /******/ // Create a new module (and put it into the cache) |
| /******/ var module = __webpack_module_cache__[moduleId] = { |
| /******/ // no module.id needed |
| /******/ // no module.loaded needed |
| /******/ exports: {} |
| /******/ }; |
| /******/ |
| /******/ // Execute the module function |
| /******/ var threw = true; |
| /******/ try { |
| /******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__); |
| /******/ threw = false; |
| /******/ } finally { |
| /******/ if(threw) delete __webpack_module_cache__[moduleId]; |
| /******/ } |
| /******/ |
| /******/ // Return the exports of the module |
| /******/ return module.exports; |
| /******/ } |
| /******/ |
| /************************************************************************/ |
| /******/ /* webpack/runtime/compat */ |
| /******/ |
| /******/ __nccwpck_require__.ab = __dirname + "/";/************************************************************************/ |
| /******/ // module exports must be returned from runtime so entry inlining is disabled |
| /******/ // startup |
| /******/ // Load entry module and return exports |
| /******/ return __nccwpck_require__(3109); |
| /******/ })() |
| ; |
| //# sourceMappingURL=index.js.map |