diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index 64f1d2408..5f93ffa53 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -18,8 +18,16 @@ jobs: with: node-version: 14.x + - name: Cache node_modules + id: cache-modules + uses: actions/cache@v1 + with: + path: node_modules + key: ${{ runner.OS }}-build-${{ hashFiles('yarn.lock') }} + - name: Install dependencies - run: yarn --frozen-lockfile + if: steps.cache-modules.outputs.cache-hit != 'true' + run: yarn install --immutable - name: Build run: yarn build diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 84e118c22..056cb944a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -19,5 +19,5 @@ jobs: with: node-version: 10.x - - run: yarn install --frozen-lockfile + - run: yarn install --immutable - run: yarn release diff --git a/.gitignore b/.gitignore index 2152da499..b6d161c59 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,16 @@ lib .now .vscode .idea +build + +.DS_Store +cypress/videos/* +cypress/screenshots/* + +.yarn/* +!.yarn/patches +!.yarn/releases +!.yarn/plugins +!.yarn/sdks +!.yarn/versions +.pnp.* \ No newline at end of file diff --git a/.yarn/releases/yarn-berry.cjs b/.yarn/releases/yarn-berry.cjs new file mode 100755 index 000000000..126430a7c --- /dev/null +++ b/.yarn/releases/yarn-berry.cjs @@ -0,0 +1,66596 @@ +#!/usr/bin/env node +module.exports = (() => { + var e = { + 25545: (e) => { + function t(e) { + var t = new Error("Cannot find module '" + e + "'"); + throw ((t.code = 'MODULE_NOT_FOUND'), t); + } + (t.keys = () => []), (t.resolve = t), (t.id = 25545), (e.exports = t); + }, + 44692: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => g }); + var A = r(54143); + const n = { optional: !0 }, + o = [ + [ + '@samverschueren/stream-to-observable@<0.3.1', + { peerDependenciesMeta: { rxjs: n, zenObservable: n } }, + ], + [ + 'any-observable@<0.5.1', + { peerDependenciesMeta: { rxjs: n, zenObservable: n } }, + ], + ['@pm2/agent@<1.0.4', { dependencies: { debug: '*' } }], + ['debug@<4.2.0', { peerDependenciesMeta: { 'supports-color': n } }], + [ + 'got@<11', + { + dependencies: { + '@types/responselike': '^1.0.0', + '@types/keyv': '^3.1.1', + }, + }, + ], + [ + 'cacheable-lookup@<4.1.2', + { dependencies: { '@types/keyv': '^3.1.1' } }, + ], + [ + 'http-link-dataloader@*', + { peerDependencies: { graphql: '^0.13.1 || ^14.0.0' } }, + ], + [ + 'typescript-language-server@*', + { + dependencies: { + 'vscode-jsonrpc': '^5.0.1', + 'vscode-languageserver-protocol': '^3.15.0', + }, + }, + ], + [ + 'postcss-syntax@*', + { + peerDependenciesMeta: { + 'postcss-html': n, + 'postcss-jsx': n, + 'postcss-less': n, + 'postcss-markdown': n, + 'postcss-scss': n, + }, + }, + ], + [ + 'jss-plugin-rule-value-function@<=10.1.1', + { dependencies: { 'tiny-warning': '^1.0.2' } }, + ], + [ + 'ink-select-input@<4.1.0', + { peerDependencies: { react: '^16.8.2' } }, + ], + ['promise-inflight@*', { peerDependenciesMeta: { bluebird: n } }], + ['reactcss@*', { peerDependencies: { react: '*' } }], + ['react-color@<=2.19.0', { peerDependencies: { react: '*' } }], + ['gatsby-plugin-i18n@*', { dependencies: { ramda: '^0.24.1' } }], + [ + 'useragent@^2.0.0', + { + dependencies: { + request: '^2.88.0', + yamlparser: '0.0.x', + semver: '5.5.x', + }, + }, + ], + [ + '@apollographql/apollo-tools@*', + { peerDependencies: { graphql: '^14.2.1 || ^15.0.0' } }, + ], + [ + 'material-table@^2.0.0', + { dependencies: { '@babel/runtime': '^7.11.2' } }, + ], + ['@babel/parser@*', { dependencies: { '@babel/types': '^7.8.3' } }], + [ + 'fork-ts-checker-webpack-plugin@*', + { + peerDependencies: { + eslint: '>= 6', + typescript: '>= 2.7', + webpack: '>= 4', + }, + peerDependenciesMeta: { eslint: n }, + }, + ], + [ + 'rc-animate@*', + { + peerDependencies: { + react: '^15.0.0 || ^16.0.0', + 'react-dom': '^15.0.0 || ^16.0.0', + }, + }, + ], + [ + 'react-bootstrap-table2-paginator@*', + { dependencies: { classnames: '^2.2.6' } }, + ], + [ + 'react-draggable@<=4.4.3', + { + peerDependencies: { + react: '>= 16.3.0', + 'react-dom': '>= 16.3.0', + }, + }, + ], + [ + 'apollo-upload-client@<14', + { peerDependencies: { graphql: '14 - 15' } }, + ], + [ + 'react-instantsearch-core@<=6.7.0', + { peerDependencies: { algoliasearch: '>= 3.1 < 5' } }, + ], + [ + 'react-instantsearch-dom@<=6.7.0', + { dependencies: { 'react-fast-compare': '^3.0.0' } }, + ], + [ + 'ws@<7.2.1', + { + peerDependencies: { + bufferutil: '^4.0.1', + 'utf-8-validate': '^5.0.2', + }, + peerDependenciesMeta: { bufferutil: n, 'utf-8-validate': n }, + }, + ], + [ + 'react-portal@*', + { + peerDependencies: { + 'react-dom': '^15.0.0-0 || ^16.0.0-0 || ^17.0.0-0', + }, + }, + ], + ]; + let i, s, a; + const c = new Map([ + [ + A.makeIdent(null, 'fsevents').identHash, + function () { + return ( + void 0 === i && + (i = r(78761) + .brotliDecompressSync( + Buffer.from( + 'G7weAByFTVk3Vs7UfHhq4yykgEM7pbW7TI43SG2S5tvGrwHBAzdz+s/npQ6tgEvobvxisrPIadkXeUAJotBn5bDZ5kAhcRqsIHe3F75Walet5hNalwgFDtxb0BiDUjiUQkjG0yW2hto9HPgiCkm316d6bC0kST72YN7D7rfkhCE9x4J0XwB0yavalxpUu2t9xszHrmtwalOxT7VslsxWcB1qpqZwERUra4psWhTV8BgwWeizurec82Caf1ABL11YMfbf8FJ9JBceZOkgmvrQPbC9DUldX/yMbmX06UQluCEjSwUoyO+EZPIjofr+/oAZUck2enraRD+oWLlnlYnj8xB+gwSo9lmmks4fXv574qSqcWA6z21uYkzMu3EWj+K23RxeQlLqiE35/rC8GcS4CGkKHKKq+zAIQwD9iRDNfiAqueLLpicFFrNsAI4zeTD/eO9MHcnRa5m8UT+M2+V+AkFST4BlKneiAQRSdST8KEAIyFlULt6wa9EBd0Ds28VmpaxquJdVt+nwdEs5xUskI13OVtFyY0UrQIRAlCuvvWivvlSKQfTO+2Q8OyUR1W5RvetaPz4jD27hdtwHFFA1Ptx6Ee/t2cY2rg2G46M1pNDRf2pWhvpy8pqMnuI3++4OF3+7OFIWXGjh+o7Nr2jNvbiYcQdQS1h903/jVFgOpA0yJ78z+x759bFA0rq+6aY5qPB4FzS3oYoLupDUhD9nDz6F6H7hpnlMf18KNKDu4IKjTWwrAnY6MFQw1W6ymOALHlFyCZmQhldg1MQHaMVVQTVgDC60TfaBqG++Y8PEoFhN/PBTZT175KNP/BlHDYGOOBmnBdzqJKplZ/ljiVG0ZBzfqeBRrrUkn6rA54462SgiliKoYVnbeptMdXNfAuaupIEi0bApF10TlgHfmEJAPUVidRVFyDupSem5po5vErPqWKhKbUIp0LozpYsIKK57dM/HKr+nguF+7924IIWMICkQ8JUigs9D+W+c4LnNoRtPPKNRUiCYmP+Jfo2lfKCKw8qpraEeWU3uiNRO6zcyKQoXPR5htmzzLznke7b4YbXW3I1lIRzmgG02Udb58U+7TpwyN7XymCgH+wuPDthZVQvRZuEP+SnLtMicz9m5zASWOBiAcLmkuFlTKuHspSIhCBD0yUPKcxu81A+4YD78rA2vtwsUEday9WNyrShyrl60rWmA+SmbYZkQOwFJWArxRYYc5jGhA5ikxYw1rx3ei4NmeX/lKiwpZ9Ln1tV2Ae7sArvxuVLbJjqJRjW1vFXAyHpvLG+8MJ6T2Ubx5M2KDa2SN6vuIGxJ9WQM9Mk3Q7aCNiZONXllhqq24DmoLbQfW2rYWsOgHWjtOmIQMyMKdiHZDjoyIq5+U700nZ6odJAoYXPQBvFNiQ78d5jaXliBqLTJEqUCwi+LiH2mx92EmNKDsJL74Z613+3lf20pxkV1+erOrjj8pW00vsPaahKUM+05ssd5uwM7K482KWEf3TCwlg/o3e5ngto7qSMz7YteIgCsF1UOcsLk7F7MxWbvrPMY473ew0G+noVL8EPbkmEMftMSeL6HFub/zy+2JQ==', + 'base64' + ) + ) + .toString()), + i + ); + }, + ], + [ + A.makeIdent(null, 'resolve').identHash, + function () { + return ( + void 0 === s && + (s = r(78761) + .brotliDecompressSync( + Buffer.from( + 'G1QTIIzURnVBnGa0VPvr81orV8AFIqdU0sqrdcVgCdukgAZwi8a50gLk9+19Z2NcUILjmzXkzt4dzm5a6Yoys+/9qnKiaApXukOiuoyUaMcynG4X7X4vBaIE/PL30gwG6HSGJkLxb9PnLjfMr+748n7sM6C/NycK6ber/bX1reVVxta6W/31tZIhfrS+upoE/TPRHj0S/l0T59gTGdtKOp1OmMOJt9rhfucDdLJ2tgyfnO+u4YMkQAcYq/nebTcDmbXhqhgo6iQA4M3m4xya4Cos3p6klmkmQT+S4DLDZfwfMF+sUCx36KleOtaHLQfEIz0Bmncj/Ngi3lqOl4391EWEfIss6gVp3oDUGwsSZJKeOVONJWZg+Mue3KUMV3aMqYJ+7b2219D+GFDi8EV5y/Y+5J+He0oNjKAgqLsJziEsS9uIaCu3BHBKSXxNKKa2ShbfglcWoiiVT2kfGI7Gw+YJ/Sqy1H6wdFWtyVUQIa82JPwbeV25YKLzc5ZIFM6GCPSA+J9dTvJbs5LuuKnLP3f09gCu2jxqsAv6CA+ZySVaUJr2d3A70BC/uBCKr2OVrWgC3fSwb7NlfkgSEEiejrMGvhya9lMbVI6lMsFKN330A1/FOaefHQdNGLEZ3IwFF87H3xVlM0Xxsmbi/7A60oymRcIe0tH90alG6ez/yA7jwYotxuHWZdR+1HlMcddGHAV6QD/gXYPV0wnNv47I+5FGevzZFMqWSO8GU4nQ3FjsdgdJcD+c1rvudERKuLyd7bxiBpnsMDHsvPP4nXdXkld/gUNks3GAE1Otmb90bavDyiw4Mrx496Iw+jbLTgsCZGZXSZ9vM55C7KGe4HyJAKXEk0iT/Cj/PFwLJBN7pcP7ZFfYtUApGTWKkYhI9IE2zt/5ByH72wdvH+88b71zuv/FMCX3w6x5nzhY44Cg5IYv9LeKwHuHIWgPbfgrAcUxOlKkPRdQOIDF/aBuLPJAXD+TgxCNXx4jQxeR/qlBWVikFPfEI4rXMUc4kZ2w9KbPKYRvFUag0dVlVoyUP4zfidbTXAdZF88jAckl+NHjLFCNdX7EQ1PbLSOl+P+MqgwEOCi6dxgWZ7NCwJBjWKpk1LaxwKrhZ4aEC/0lMPJYe5S8xAakDcmA2kSS86GjEMTrv3VEu0S0YGZcxToMV524G4WAc4CReePePdipvs4aXRL5p+aeN96yfMGjsiTbQNxgbdRKc+keQ+NxYIEm1mBtEO29WrcbrqNbQRMR66KpGG4aG0NtmRyZ2JhUvu0paCklRlID8PT3gSiwZrqr4XZXoBBzBMrveWCuOg7iTgGDXDdbGi8XHkQf5KXDGFUxWueu5wkSa6gMWY1599g2piQjwBKIAPt4N5cOZdFBidz2feGwEAy1j1UydGxDSCCUsh314cUIIRV/dWCheceubL2gU8CibewmP7UxmN5kN4I7zfQhPxkP0NCcei8GXQpw4c3krEzW7PR2hgi/hqqqR58UJ/ZVfWxfcH5ZKMo4itkmPK0FCGxzzIRP20lK/gz28Y03sY233KvSVWUKl9rcbX6MbHjpUG8MvNlw72p6FwTejv92zgpnCxVJnIHHZhCBxNcHF5RTveRp513hUtTHHq4BIndlytZT5xoTSYfHKqKNr4o9kcGINIz6tZSKRdtbON3Ydr9cgqxHIeisMNIsvPg/IFMZuBbSqqDLeSO5dak1cGr76FtH2PC7hs0S0Oq3GsmF1Ga4YABAMGcdPAWzTk26B7cKV91I2b0V/GYvnsEQ1YGntRqi5EQqTlgZszbV/32GuZtUF49JOA/r4jAdwUOsbPo6mNoBlJPYjM5axrZaWQf33bFsLWqiyvvDOM4x0Ng802T7cuP2a3q98GWq6yiq6q3M77hcZlOUnmryctRYmI4Hb2F5XixFohkBmySCjU+M7/WQVE5YAtnlxiUJDhFN0y1tNeMWY9E0MfZi2rQ4eC72WXjsAA==', + 'base64' + ) + ) + .toString()), + s + ); + }, + ], + [ + A.makeIdent(null, 'typescript').identHash, + function () { + return ( + void 0 === a && + (a = r(78761) + .brotliDecompressSync( + Buffer.from( + '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', + 'base64' + ) + ) + .toString()), + a + ); + }, + ], + ]), + g = { + hooks: { + registerPackageExtensions: async (e, t) => { + for (const [e, r] of o) t(A.parseDescriptor(e, !0), r); + }, + getBuiltinPatch: async (e, t) => { + var r; + if (!t.startsWith('compat/')) return; + const n = A.parseIdent(t.slice('compat/'.length)), + o = + null === (r = c.get(n.identHash)) || void 0 === r + ? void 0 + : r(); + return void 0 !== o ? o : null; + }, + reduceDependency: async (e, t, r, n) => + void 0 === c.get(e.identHash) + ? e + : A.makeDescriptor( + e, + A.makeRange({ + protocol: 'patch:', + source: A.stringifyDescriptor(e), + selector: `builtin`, + params: null, + }) + ), + }, + }; + }, + 10189: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => p }); + var A = r(36370), + n = r(25413), + o = r(54143), + i = r(40822); + class s extends n.BaseCommand { + constructor() { + super(...arguments), (this.quiet = !1), (this.args = []); + } + async execute() { + const e = []; + this.pkg && e.push('--package', this.pkg), + this.quiet && e.push('--quiet'); + const t = o.parseIdent(this.command), + r = o.makeIdent(t.scope, 'create-' + t.name); + return this.cli.run([ + 'dlx', + ...e, + o.stringifyIdent(r), + ...this.args, + ]); + } + } + (0, A.gn)( + [ + i.Command.String('-p,--package', { + description: 'The package to run the provided command from', + }), + ], + s.prototype, + 'pkg', + void 0 + ), + (0, A.gn)( + [ + i.Command.Boolean('-q,--quiet', { + description: + 'Only report critical errors instead of printing the full install logs', + }), + ], + s.prototype, + 'quiet', + void 0 + ), + (0, A.gn)([i.Command.String()], s.prototype, 'command', void 0), + (0, A.gn)([i.Command.Proxy()], s.prototype, 'args', void 0), + (0, A.gn)([i.Command.Path('create')], s.prototype, 'execute', null); + var a = r(39922), + c = r(85824), + g = r(63088), + l = r(43896), + u = r(46009); + class h extends n.BaseCommand { + constructor() { + super(...arguments), (this.quiet = !1), (this.args = []); + } + async execute() { + return ( + (a.VK.telemetry = null), + await l.xfs.mktempPromise(async (e) => { + const t = u.y1.join(e, 'dlx-' + process.pid); + await l.xfs.mkdirPromise(t), + await l.xfs.writeFilePromise( + u.y1.join(t, 'package.json'), + '{}\n' + ), + await l.xfs.writeFilePromise(u.y1.join(t, 'yarn.lock'), ''); + const r = u.y1.join(t, '.yarnrc.yml'), + A = await a.VK.findProjectCwd( + this.context.cwd, + u.QS.lockfile + ), + i = null !== A ? u.y1.join(A, '.yarnrc.yml') : null; + null !== i && l.xfs.existsSync(i) + ? (await l.xfs.copyFilePromise(i, r), + await a.VK.updateConfiguration(t, (e) => { + const t = { + ...e, + enableGlobalCache: !0, + enableTelemetry: !1, + }; + return ( + Array.isArray(e.plugins) && + (t.plugins = e.plugins.map((e) => { + const t = 'string' == typeof e ? e : e.path, + r = u.cS.isAbsolute(t) + ? t + : u.cS.resolve(u.cS.fromPortablePath(A), t); + return 'string' == typeof e + ? r + : { path: r, spec: e.spec }; + })), + t + ); + })) + : await l.xfs.writeFilePromise( + r, + 'enableGlobalCache: true\nenableTelemetry: false\n' + ); + const s = void 0 !== this.pkg ? [this.pkg] : [this.command], + h = o.parseDescriptor(this.command).name, + p = await this.cli.run(['add', '--', ...s], { + cwd: t, + quiet: this.quiet, + }); + if (0 !== p) return p; + this.quiet || this.context.stdout.write('\n'); + const d = await a.VK.find(t, this.context.plugins), + { project: C, workspace: f } = await c.I.find(d, t); + if (null === f) throw new n.WorkspaceRequiredError(C.cwd, t); + return ( + await C.restoreInstallState(), + await g.executeWorkspaceAccessibleBinary(f, h, this.args, { + cwd: this.context.cwd, + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + }) + ); + }) + ); + } + } + (h.usage = i.Command.Usage({ + description: 'run a package in a temporary environment', + details: + "\n This command will install a package within a temporary environment, and run its binary script if it contains any. The binary will run within the current cwd.\n\n By default Yarn will download the package named `command`, but this can be changed through the use of the `-p,--package` flag which will instruct Yarn to still run the same command but from a different package.\n\n Using `yarn dlx` as a replacement of `yarn add` isn't recommended, as it makes your project non-deterministic (Yarn doesn't keep track of the packages installed through `dlx` - neither their name, nor their version).\n ", + examples: [ + [ + 'Use create-react-app to create a new React app', + 'yarn dlx create-react-app ./my-app', + ], + ], + })), + (0, A.gn)( + [ + i.Command.String('-p,--package', { + description: 'The package to run the provided command from', + }), + ], + h.prototype, + 'pkg', + void 0 + ), + (0, A.gn)( + [ + i.Command.Boolean('-q,--quiet', { + description: + 'Only report critical errors instead of printing the full install logs', + }), + ], + h.prototype, + 'quiet', + void 0 + ), + (0, A.gn)([i.Command.String()], h.prototype, 'command', void 0), + (0, A.gn)([i.Command.Proxy()], h.prototype, 'args', void 0), + (0, A.gn)([i.Command.Path('dlx')], h.prototype, 'execute', null); + const p = { commands: [s, h] }; + }, + 34777: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + dedupeUtils: () => A, + default: () => We, + suggestUtils: () => A, + }); + var A = {}; + r.r(A), + r.d(A, { + Modifier: () => o, + Strategy: () => i, + Target: () => n, + applyModifier: () => S, + extractDescriptorFromPath: () => N, + extractRangeModifier: () => v, + fetchDescriptorFrom: () => K, + findProjectDescriptors: () => k, + getModifier: () => D, + getSuggestedDescriptors: () => F, + }); + var n, + o, + i, + s = r(39922), + a = r(36370), + c = r(25413), + g = r(28148), + l = r(62152), + u = r(92659), + h = r(85824), + p = r(15815), + d = r(54143), + C = r(40822), + f = r(61899), + I = r(33720), + E = r(46611), + B = r(71643), + y = r(43896), + m = r(46009), + w = r(53887), + Q = r.n(w); + function D(e, t) { + return e.exact + ? o.EXACT + : e.caret + ? o.CARET + : e.tilde + ? o.TILDE + : t.configuration.get('defaultSemverRangePrefix'); + } + !(function (e) { + (e.REGULAR = 'dependencies'), + (e.DEVELOPMENT = 'devDependencies'), + (e.PEER = 'peerDependencies'); + })(n || (n = {})), + (function (e) { + (e.CARET = '^'), (e.TILDE = '~'), (e.EXACT = ''); + })(o || (o = {})), + (function (e) { + (e.KEEP = 'keep'), + (e.REUSE = 'reuse'), + (e.PROJECT = 'project'), + (e.LATEST = 'latest'), + (e.CACHE = 'cache'); + })(i || (i = {})); + const b = /^([\^~]?)[0-9]+(?:\.[0-9]+){0,2}(?:-\S+)?$/; + function v(e, { project: t }) { + const r = e.match(b); + return r ? r[1] : t.configuration.get('defaultSemverRangePrefix'); + } + function S(e, t) { + let { protocol: r, source: A, params: n, selector: o } = d.parseRange( + e.range + ); + return ( + Q().valid(o) && (o = `${t}${e.range}`), + d.makeDescriptor( + e, + d.makeRange({ protocol: r, source: A, params: n, selector: o }) + ) + ); + } + async function k(e, { project: t, target: r }) { + const A = new Map(), + o = (e) => { + let t = A.get(e.descriptorHash); + return ( + t || + A.set( + e.descriptorHash, + (t = { descriptor: e, locators: [] }) + ), + t + ); + }; + for (const A of t.workspaces) + if (r === n.PEER) { + const t = A.manifest.peerDependencies.get(e.identHash); + void 0 !== t && o(t).locators.push(A.locator); + } else { + const t = A.manifest.dependencies.get(e.identHash), + i = A.manifest.devDependencies.get(e.identHash); + r === n.DEVELOPMENT + ? void 0 !== i + ? o(i).locators.push(A.locator) + : void 0 !== t && o(t).locators.push(A.locator) + : void 0 !== t + ? o(t).locators.push(A.locator) + : void 0 !== i && o(i).locators.push(A.locator); + } + return A; + } + async function N(e, { cwd: t, workspace: r }) { + return await (async function (e) { + return await y.xfs.mktempPromise(async (t) => { + const r = s.VK.create(t); + return ( + r.useWithSource( + t, + { enableMirror: !1, compressionLevel: 0 }, + t, + { overwrite: !0 } + ), + await e( + new g.C(t, { configuration: r, check: !1, immutable: !1 }) + ) + ); + }); + })(async (A) => { + m.y1.isAbsolute(e) || + (e = m.y1.relative(r.cwd, m.y1.resolve(t, e))).match( + /^\.{0,2}\// + ) || + (e = './' + e); + const { project: n } = r, + o = await K(d.makeIdent(null, 'archive'), e, { + project: r.project, + cache: A, + workspace: r, + }); + if (!o) + throw new Error( + 'Assertion failed: The descriptor should have been found' + ); + const i = new I.$(), + s = n.configuration.makeResolver(), + a = n.configuration.makeFetcher(), + c = { + checksums: n.storedChecksums, + project: n, + cache: A, + fetcher: a, + report: i, + resolver: s, + }, + g = s.bindDescriptor(o, r.anchoredLocator, c), + l = d.convertDescriptorToLocator(g), + u = await a.fetch(l, c), + h = await E.G.find(u.prefixPath, { baseFs: u.packageFs }); + if (!h.name) throw new Error("Target path doesn't have a name"); + return d.makeDescriptor(h.name, e); + }); + } + async function F( + e, + { + project: t, + workspace: r, + cache: A, + target: o, + modifier: s, + strategies: a, + maxResults: c = 1 / 0, + } + ) { + if (!(c >= 0)) throw new Error(`Invalid maxResults (${c})`); + if ('unknown' !== e.range) + return { + suggestions: [ + { + descriptor: e, + name: 'Use ' + d.prettyDescriptor(t.configuration, e), + reason: '(unambiguous explicit request)', + }, + ], + rejections: [], + }; + const g = (null != r && r.manifest[o].get(e.identHash)) || null, + l = [], + u = [], + h = async (e) => { + try { + await e(); + } catch (e) { + u.push(e); + } + }; + for (const u of a) { + if (l.length >= c) break; + switch (u) { + case i.KEEP: + await h(async () => { + g && + l.push({ + descriptor: g, + name: 'Keep ' + d.prettyDescriptor(t.configuration, g), + reason: '(no changes)', + }); + }); + break; + case i.REUSE: + await h(async () => { + for (const { descriptor: A, locators: n } of ( + await k(e, { project: t, target: o }) + ).values()) { + if ( + 1 === n.length && + n[0].locatorHash === r.anchoredLocator.locatorHash && + a.includes(i.KEEP) + ) + continue; + let e = + '(originally used by ' + + d.prettyLocator(t.configuration, n[0]); + (e += + n.length > 1 + ? ` and ${n.length - 1} other${ + n.length > 2 ? 's' : '' + })` + : ')'), + l.push({ + descriptor: A, + name: 'Reuse ' + d.prettyDescriptor(t.configuration, A), + reason: e, + }); + } + }); + break; + case i.CACHE: + await h(async () => { + for (const r of t.storedDescriptors.values()) + r.identHash === e.identHash && + l.push({ + descriptor: r, + name: 'Reuse ' + d.prettyDescriptor(t.configuration, r), + reason: '(already used somewhere in the lockfile)', + }); + }); + break; + case i.PROJECT: + await h(async () => { + if ( + null !== r.manifest.name && + e.identHash === r.manifest.name.identHash + ) + return; + const A = t.tryWorkspaceByIdent(e); + null !== A && + l.push({ + descriptor: A.anchoredDescriptor, + name: 'Attach ' + d.prettyWorkspace(t.configuration, A), + reason: `(local workspace at ${A.cwd})`, + }); + }); + break; + case i.LATEST: + await h(async () => { + if ('unknown' !== e.range) + l.push({ + descriptor: e, + name: 'Use ' + d.prettyRange(t.configuration, e.range), + reason: '(explicit range requested)', + }); + else if (o === n.PEER) + l.push({ + descriptor: d.makeDescriptor(e, '*'), + name: 'Use *', + reason: '(catch-all peer dependency pattern)', + }); + else if (t.configuration.get('enableNetwork')) { + let n = await K(e, 'latest', { + project: t, + cache: A, + workspace: r, + preserveModifier: !1, + }); + n && + ((n = S(n, s)), + l.push({ + descriptor: n, + name: 'Use ' + d.prettyDescriptor(t.configuration, n), + reason: '(resolved from latest)', + })); + } else + l.push({ + descriptor: null, + name: 'Resolve from latest', + reason: B.pretty( + t.configuration, + '(unavailable because enableNetwork is toggled off)', + 'grey' + ), + }); + }); + } + } + return { suggestions: l.slice(0, c), rejections: u.slice(0, c) }; + } + async function K( + e, + t, + { project: r, cache: A, workspace: n, preserveModifier: o = !0 } + ) { + const i = d.makeDescriptor(e, t), + s = new I.$(), + a = r.configuration.makeFetcher(), + c = r.configuration.makeResolver(), + g = { + project: r, + fetcher: a, + cache: A, + checksums: r.storedChecksums, + report: s, + skipIntegrityCheck: !0, + }, + l = { ...g, resolver: c, fetchOptions: g }, + u = c.bindDescriptor(i, n.anchoredLocator, l), + h = await c.getCandidates(u, new Map(), l); + if (0 === h.length) return null; + const p = h[0]; + let { protocol: C, source: f, params: E, selector: B } = d.parseRange( + d.convertToManifestRange(p.reference) + ); + if ( + (C === r.configuration.get('defaultProtocol') && (C = null), + Q().valid(B) && !1 !== o) + ) { + B = v('string' == typeof o ? o : i.range, { project: r }) + B; + } + return d.makeDescriptor( + p, + d.makeRange({ protocol: C, source: f, params: E, selector: B }) + ); + } + class M extends c.BaseCommand { + constructor() { + super(...arguments), + (this.packages = []), + (this.json = !1), + (this.exact = !1), + (this.tilde = !1), + (this.caret = !1), + (this.dev = !1), + (this.peer = !1), + (this.optional = !1), + (this.preferDev = !1), + (this.interactive = null), + (this.cached = !1); + } + async execute() { + var e; + const t = await s.VK.find(this.context.cwd, this.context.plugins), + { project: r, workspace: A } = await h.I.find( + t, + this.context.cwd + ), + o = await g.C.find(t); + if (!A) throw new c.WorkspaceRequiredError(r.cwd, this.context.cwd); + await r.restoreInstallState({ restoreResolutions: !1 }); + const a = + null !== (e = this.interactive) && void 0 !== e + ? e + : t.get('preferInteractive'), + I = D(this, r), + E = [ + ...(a ? [i.REUSE] : []), + i.PROJECT, + ...(this.cached ? [i.CACHE] : []), + i.LATEST, + ], + B = a ? 1 / 0 : 1, + y = await Promise.all( + this.packages.map(async (e) => { + const t = e.match(/^\.{0,2}\//) + ? await N(e, { cwd: this.context.cwd, workspace: A }) + : d.parseDescriptor(e), + i = (function ( + e, + t, + { dev: r, peer: A, preferDev: o, optional: i } + ) { + const s = e.manifest[n.REGULAR].has(t.identHash), + a = e.manifest[n.DEVELOPMENT].has(t.identHash), + c = e.manifest[n.PEER].has(t.identHash); + if ((r || A) && s) + throw new C.UsageError( + `Package "${d.prettyIdent( + e.project.configuration, + t + )}" is already listed as a regular dependency - remove the -D,-P flags or remove it from your dependencies first` + ); + if (!r && !A && c) + throw new C.UsageError( + `Package "${d.prettyIdent( + e.project.configuration, + t + )}" is already listed as a peer dependency - use either of -D or -P, or remove it from your peer dependencies first` + ); + if (i && a) + throw new C.UsageError( + `Package "${d.prettyIdent( + e.project.configuration, + t + )}" is already listed as a dev dependency - remove the -O flag or remove it from your dev dependencies first` + ); + if (i && !A && c) + throw new C.UsageError( + `Package "${d.prettyIdent( + e.project.configuration, + t + )}" is already listed as a peer dependency - remove the -O flag or add the -P flag or remove it from your peer dependencies first` + ); + if ((r || o) && i) + throw new C.UsageError( + `Package "${d.prettyIdent( + e.project.configuration, + t + )}" cannot simultaneously be a dev dependency and an optional dependency` + ); + return A + ? n.PEER + : r || o + ? n.DEVELOPMENT + : s + ? n.REGULAR + : a + ? n.DEVELOPMENT + : n.REGULAR; + })(A, t, { + dev: this.dev, + peer: this.peer, + preferDev: this.preferDev, + optional: this.optional, + }); + return [ + t, + await F(t, { + project: r, + workspace: A, + cache: o, + target: i, + modifier: I, + strategies: E, + maxResults: B, + }), + i, + ]; + }) + ), + m = await l.h.start( + { + configuration: t, + stdout: this.context.stdout, + suggestInstall: !1, + }, + async (e) => { + for (const [A, { suggestions: n, rejections: o }] of y) { + if (0 === n.filter((e) => null !== e.descriptor).length) { + const [n] = o; + if (void 0 === n) + throw new Error( + 'Assertion failed: Expected an error to have been set' + ); + const i = this.cli.error(n); + r.configuration.get('enableNetwork') + ? e.reportError( + u.b.CANT_SUGGEST_RESOLUTIONS, + `${d.prettyDescriptor( + t, + A + )} can't be resolved to a satisfying range:\n\n${i}` + ) + : e.reportError( + u.b.CANT_SUGGEST_RESOLUTIONS, + `${d.prettyDescriptor( + t, + A + )} can't be resolved to a satisfying range (note: network resolution has been disabled):\n\n${i}` + ); + } + } + } + ); + if (m.hasErrors()) return m.exitCode(); + let w = !1; + const Q = [], + b = []; + for (const [, { suggestions: e }, t] of y) { + let r; + const n = e.filter((e) => null !== e.descriptor), + o = n[0].descriptor, + i = n.every((e) => d.areDescriptorsEqual(e.descriptor, o)); + 1 === n.length || i + ? (r = o) + : ((w = !0), + ({ answer: r } = await (0, f.prompt)({ + type: 'select', + name: 'answer', + message: 'Which range do you want to use?', + choices: e.map(({ descriptor: e, name: t, reason: r }) => + e + ? { name: t, hint: r, descriptor: e } + : { name: t, hint: r, disabled: !0 } + ), + onCancel: () => process.exit(130), + result(e) { + return this.find(e, 'descriptor'); + }, + stdin: this.context.stdin, + stdout: this.context.stdout, + }))); + const s = A.manifest[t].get(r.identHash); + (void 0 !== s && s.descriptorHash === r.descriptorHash) || + (A.manifest[t].set(r.identHash, r), + this.optional && + ('dependencies' === t + ? (A.manifest.ensureDependencyMeta({ + ...r, + range: 'unknown', + }).optional = !0) + : 'peerDependencies' === t && + (A.manifest.ensurePeerDependencyMeta({ + ...r, + range: 'unknown', + }).optional = !0)), + void 0 === s ? Q.push([A, t, r, E]) : b.push([A, t, s, r])); + } + await t.triggerMultipleHooks( + (e) => e.afterWorkspaceDependencyAddition, + Q + ), + await t.triggerMultipleHooks( + (e) => e.afterWorkspaceDependencyReplacement, + b + ), + w && this.context.stdout.write('\n'); + return ( + await p.Pk.start( + { + configuration: t, + json: this.json, + stdout: this.context.stdout, + includeLogs: !this.context.quiet, + }, + async (e) => { + await r.install({ cache: o, report: e }); + } + ) + ).exitCode(); + } + } + (M.usage = C.Command.Usage({ + description: 'add dependencies to the project', + details: + "\n This command adds a package to the package.json for the nearest workspace.\n\n - If it didn't exist before, the package will by default be added to the regular `dependencies` field, but this behavior can be overriden thanks to the `-D,--dev` flag (which will cause the dependency to be added to the `devDependencies` field instead) and the `-P,--peer` flag (which will do the same but for `peerDependencies`).\n\n - If the package was already listed in your dependencies, it will by default be upgraded whether it's part of your `dependencies` or `devDependencies` (it won't ever update `peerDependencies`, though).\n\n - If set, the `--prefer-dev` flag will operate as a more flexible `-D,--dev` in that it will add the package to your `devDependencies` if it isn't already listed in either `dependencies` or `devDependencies`, but it will also happily upgrade your `dependencies` if that's what you already use (whereas `-D,--dev` would throw an exception).\n\n - If set, the `-O,--optional` flag will add the package to the `optionalDependencies` field and, in combination with the `-P,--peer` flag, it will add the package as an optional peer dependency. If the package was already listed in your `dependencies`, it will be upgraded to `optionalDependencies`. If the package was already listed in your `peerDependencies`, in combination with the `-P,--peer` flag, it will be upgraded to an optional peer dependency: `\"peerDependenciesMeta\": { \"\": { \"optional\": true } }`\n\n - If the added package doesn't specify a range at all its `latest` tag will be resolved and the returned version will be used to generate a new semver range (using the `^` modifier by default unless otherwise configured via the `defaultSemverRangePrefix` configuration, or the `~` modifier if `-T,--tilde` is specified, or no modifier at all if `-E,--exact` is specified). Two exceptions to this rule: the first one is that if the package is a workspace then its local version will be used, and the second one is that if you use `-P,--peer` the default range will be `*` and won't be resolved at all.\n\n - If the added package specifies a range (such as `^1.0.0`, `latest`, or `rc`), Yarn will add this range as-is in the resulting package.json entry (in particular, tags such as `rc` will be encoded as-is rather than being converted into a semver range).\n\n If the `--cached` option is used, Yarn will preferably reuse the highest version already used somewhere within the project, even if through a transitive dependency.\n\n If the `-i,--interactive` option is used (or if the `preferInteractive` settings is toggled on) the command will first try to check whether other workspaces in the project use the specified package and, if so, will offer to reuse them.\n\n For a compilation of all the supported protocols, please consult the dedicated page from our website: https://yarnpkg.com/features/protocols.\n ", + examples: [ + ['Add a regular package to the current workspace', '$0 add lodash'], + [ + 'Add a specific version for a package to the current workspace', + '$0 add lodash@1.2.3', + ], + [ + 'Add a package from a GitHub repository (the master branch) to the current workspace using a URL', + '$0 add lodash@https://github.com/lodash/lodash', + ], + [ + 'Add a package from a GitHub repository (the master branch) to the current workspace using the GitHub protocol', + '$0 add lodash@github:lodash/lodash', + ], + [ + 'Add a package from a GitHub repository (the master branch) to the current workspace using the GitHub protocol (shorthand)', + '$0 add lodash@lodash/lodash', + ], + [ + 'Add a package from a specific branch of a GitHub repository to the current workspace using the GitHub protocol (shorthand)', + '$0 add lodash-es@lodash/lodash#es', + ], + ], + })), + (0, a.gn)([C.Command.Rest()], M.prototype, 'packages', void 0), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + M.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-E,--exact', { + description: + "Don't use any semver modifier on the resolved range", + }), + ], + M.prototype, + 'exact', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-T,--tilde', { + description: + 'Use the `~` semver modifier on the resolved range', + }), + ], + M.prototype, + 'tilde', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-C,--caret', { + description: + 'Use the `^` semver modifier on the resolved range', + }), + ], + M.prototype, + 'caret', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-D,--dev', { + description: 'Add a package as a dev dependency', + }), + ], + M.prototype, + 'dev', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-P,--peer', { + description: 'Add a package as a peer dependency', + }), + ], + M.prototype, + 'peer', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-O,--optional', { + description: + 'Add / upgrade a package to an optional regular / peer dependency', + }), + ], + M.prototype, + 'optional', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--prefer-dev', { + description: 'Add / upgrade a package to a dev dependency', + }), + ], + M.prototype, + 'preferDev', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-i,--interactive', { + description: + 'Reuse the specified package from other workspaces in the project', + }), + ], + M.prototype, + 'interactive', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--cached', { + description: + 'Reuse the highest version already used somewhere within the project', + }), + ], + M.prototype, + 'cached', + void 0 + ), + (0, a.gn)([C.Command.Path('add')], M.prototype, 'execute', null); + var R = r(63088); + class x extends c.BaseCommand { + constructor() { + super(...arguments), (this.verbose = !1), (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, locator: r } = await h.I.find(e, this.context.cwd); + if ((await t.restoreInstallState(), this.name)) { + const A = ( + await R.getPackageAccessibleBinaries(r, { project: t }) + ).get(this.name); + if (!A) + throw new C.UsageError( + `Couldn't find a binary named "${ + this.name + }" for package "${d.prettyLocator(e, r)}"` + ); + const [, n] = A; + return this.context.stdout.write(n + '\n'), 0; + } + return ( + await p.Pk.start( + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }, + async (A) => { + const n = await R.getPackageAccessibleBinaries(r, { + project: t, + }), + o = Array.from(n.keys()).reduce( + (e, t) => Math.max(e, t.length), + 0 + ); + for (const [e, [t, r]] of n) + A.reportJson({ + name: e, + source: d.stringifyIdent(t), + path: r, + }); + if (this.verbose) + for (const [t, [r]] of n) + A.reportInfo( + null, + `${t.padEnd(o, ' ')} ${d.prettyLocator(e, r)}` + ); + else for (const e of n.keys()) A.reportInfo(null, e); + } + ) + ).exitCode(); + } + } + (x.usage = C.Command.Usage({ + description: 'get the path to a binary script', + details: + '\n When used without arguments, this command will print the list of all the binaries available in the current workspace. Adding the `-v,--verbose` flag will cause the output to contain both the binary name and the locator of the package that provides the binary.\n\n When an argument is specified, this command will just print the path to the binary on the standard output and exit. Note that the reported path may be stored within a zip archive.\n ', + examples: [ + ['List all the available binaries', '$0 bin'], + ['Print the path to a specific binary', '$0 bin eslint'], + ], + })), + (0, a.gn)( + [C.Command.String({ required: !1 })], + x.prototype, + 'name', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-v,--verbose', { + description: + 'Print both the binary name and the locator of the package that provides the binary', + }), + ], + x.prototype, + 'verbose', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + x.prototype, + 'json', + void 0 + ), + (0, a.gn)([C.Command.Path('bin')], x.prototype, 'execute', null); + class L extends c.BaseCommand { + constructor() { + super(...arguments), (this.mirror = !1), (this.all = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + t = await g.C.find(e); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async () => { + const e = (this.all || this.mirror) && null !== t.mirrorCwd, + r = !this.mirror; + e && (await y.xfs.removePromise(t.mirrorCwd)), + r && (await y.xfs.removePromise(t.cwd)); + } + ) + ).exitCode(); + } + } + (L.usage = C.Command.Usage({ + description: 'remove the shared cache files', + details: + '\n This command will remove all the files from the cache.\n ', + examples: [ + ['Remove all the local archives', '$0 cache clean'], + [ + 'Remove all the archives stored in the ~/.yarn directory', + '$0 cache clean --mirror', + ], + ], + })), + (0, a.gn)( + [ + C.Command.Boolean('--mirror', { + description: + 'Remove the global cache files instead of the local cache files', + }), + ], + L.prototype, + 'mirror', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--all', { + description: + 'Remove both the global cache files and the local cache files of the current project', + }), + ], + L.prototype, + 'all', + void 0 + ), + (0, a.gn)( + [C.Command.Path('cache', 'clean')], + L.prototype, + 'execute', + null + ); + var P = r(73632), + O = r(44674), + U = r.n(O), + T = r(31669); + class j extends c.BaseCommand { + constructor() { + super(...arguments), (this.json = !1), (this.unsafe = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + t = this.name.replace(/[.[].*$/, ''), + r = this.name.replace(/^[^.[]*/, ''); + if (void 0 === e.settings.get(t)) + throw new C.UsageError( + `Couldn't find a configuration settings named "${t}"` + ); + const A = e.getSpecial(t, { + hideSecrets: !this.unsafe, + getNativePaths: !0, + }), + n = P.convertMapsToIndexableObjects(A), + o = r ? U()(n, r) : n, + i = await p.Pk.start( + { + configuration: e, + includeFooter: !1, + json: this.json, + stdout: this.context.stdout, + }, + async (e) => { + e.reportJson(o); + } + ); + if (!this.json) { + if ('string' == typeof o) + return this.context.stdout.write(o + '\n'), i.exitCode(); + (T.inspect.styles.name = 'cyan'), + this.context.stdout.write( + (0, T.inspect)(o, { + depth: 1 / 0, + colors: e.get('enableColors'), + compact: !1, + }) + '\n' + ); + } + return i.exitCode(); + } + } + (j.usage = C.Command.Usage({ + description: 'read a configuration settings', + details: + "\n This command will print a configuration setting.\n\n Secrets (such as tokens) will be redacted from the output by default. If this behavior isn't desired, set the `--no-redacted` to get the untransformed value.\n ", + examples: [ + [ + 'Print a simple configuration setting', + 'yarn config get yarnPath', + ], + [ + 'Print a complex configuration setting', + 'yarn config get packageExtensions', + ], + [ + 'Print a nested field from the configuration', + 'yarn config get \'npmScopes["my-company"].npmRegistryServer\'', + ], + [ + 'Print a token from the configuration', + 'yarn config get npmAuthToken --no-redacted', + ], + [ + 'Print a configuration setting as JSON', + 'yarn config get packageExtensions --json', + ], + ], + })), + (0, a.gn)([C.Command.String()], j.prototype, 'name', void 0), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + j.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--no-redacted', { + description: + "Don't redact secrets (such as tokens) from the output", + }), + ], + j.prototype, + 'unsafe', + void 0 + ), + (0, a.gn)( + [C.Command.Path('config', 'get')], + j.prototype, + 'execute', + null + ); + var Y = r(82558), + G = r.n(Y), + H = r(81534), + J = r.n(H); + class q extends c.BaseCommand { + constructor() { + super(...arguments), (this.json = !1), (this.home = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins); + if (!e.projectCwd) + throw new C.UsageError( + 'This command must be run from within a project folder' + ); + const t = this.name.replace(/[.[].*$/, ''), + r = this.name.replace(/^[^.[]*\.?/, ''); + if (void 0 === e.settings.get(t)) + throw new C.UsageError( + `Couldn't find a configuration settings named "${t}"` + ); + const A = this.json ? JSON.parse(this.value) : this.value, + n = this.home + ? (e) => s.VK.updateHomeConfiguration(e) + : (t) => s.VK.updateConfiguration(e.projectCwd, t); + await n((e) => { + if (r) { + const t = G()(e); + return J()(t, this.name, A), t; + } + return { ...e, [t]: A }; + }); + const o = ( + await s.VK.find(this.context.cwd, this.context.plugins) + ).getSpecial(t, { hideSecrets: !0, getNativePaths: !0 }), + i = P.convertMapsToIndexableObjects(o), + a = r ? U()(i, r) : i; + return ( + await p.Pk.start( + { + configuration: e, + includeFooter: !1, + stdout: this.context.stdout, + }, + async (t) => { + (T.inspect.styles.name = 'cyan'), + t.reportInfo( + u.b.UNNAMED, + `Successfully set ${this.name} to ${(0, T.inspect)(a, { + depth: 1 / 0, + colors: e.get('enableColors'), + compact: !1, + })}` + ); + } + ) + ).exitCode(); + } + } + (q.usage = C.Command.Usage({ + description: 'change a configuration settings', + details: + '\n This command will set a configuration setting.\n\n When used without the `--json` flag, it can only set a simple configuration setting (a string, a number, or a boolean).\n\n When used with the `--json` flag, it can set both simple and complex configuration settings, including Arrays and Objects.\n ', + examples: [ + [ + 'Set a simple configuration setting (a string, a number, or a boolean)', + 'yarn config set initScope myScope', + ], + [ + 'Set a simple configuration setting (a string, a number, or a boolean) using the `--json` flag', + 'yarn config set initScope --json \\"myScope\\"', + ], + [ + 'Set a complex configuration setting (an Array) using the `--json` flag', + 'yarn config set unsafeHttpWhitelist --json \'["*.example.com", "example.com"]\'', + ], + [ + 'Set a complex configuration setting (an Object) using the `--json` flag', + 'yarn config set packageExtensions --json \'{ "@babel/parser@*": { "dependencies": { "@babel/types": "*" } } }\'', + ], + [ + 'Set a nested configuration setting', + 'yarn config set npmScopes.company.npmRegistryServer "https://npm.example.com"', + ], + [ + 'Set a nested configuration setting using indexed access for non-simple keys', + 'yarn config set \'npmRegistries["//npm.example.com"].npmAuthToken\' "ffffffff-ffff-ffff-ffff-ffffffffffff"', + ], + ], + })), + (0, a.gn)([C.Command.String()], q.prototype, 'name', void 0), + (0, a.gn)([C.Command.String()], q.prototype, 'value', void 0), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: + 'Set complex configuration settings to JSON values', + }), + ], + q.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-H,--home', { + description: + 'Update the home configuration instead of the project configuration', + }), + ], + q.prototype, + 'home', + void 0 + ), + (0, a.gn)( + [C.Command.Path('config', 'set')], + q.prototype, + 'execute', + null + ); + class z extends c.BaseCommand { + constructor() { + super(...arguments), + (this.verbose = !1), + (this.why = !1), + (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins, { + strict: !1, + }); + return ( + await p.Pk.start( + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }, + async (t) => { + if (e.invalid.size > 0 && !this.json) { + for (const [r, A] of e.invalid) + t.reportError( + u.b.INVALID_CONFIGURATION_KEY, + `Invalid configuration key "${r}" in ${A}` + ); + t.reportSeparator(); + } + if (this.json) { + const r = P.sortMap(e.settings.keys(), (e) => e); + for (const A of r) { + const r = e.settings.get(A), + n = e.getSpecial(A, { + hideSecrets: !0, + getNativePaths: !0, + }), + o = e.sources.get(A); + this.verbose + ? t.reportJson({ key: A, effective: n, source: o }) + : t.reportJson({ + key: A, + effective: n, + source: o, + ...r, + }); + } + } else { + const r = P.sortMap(e.settings.keys(), (e) => e), + A = r.reduce((e, t) => Math.max(e, t.length), 0), + n = { + breakLength: 1 / 0, + colors: e.get('enableColors'), + maxArrayLength: 2, + }; + if (this.why || this.verbose) { + const o = r.map((t) => { + const r = e.settings.get(t); + if (!r) + throw new Error( + `Assertion failed: This settings ("${t}") should have been registered` + ); + return [ + t, + this.why + ? e.sources.get(t) || '' + : r.description, + ]; + }), + i = o.reduce((e, [, t]) => Math.max(e, t.length), 0); + for (const [r, s] of o) + t.reportInfo( + null, + `${r.padEnd(A, ' ')} ${s.padEnd(i, ' ')} ${(0, + T.inspect)( + e.getSpecial(r, { + hideSecrets: !0, + getNativePaths: !0, + }), + n + )}` + ); + } else + for (const o of r) + t.reportInfo( + null, + `${o.padEnd(A, ' ')} ${(0, T.inspect)( + e.getSpecial(o, { + hideSecrets: !0, + getNativePaths: !0, + }), + n + )}` + ); + } + } + ) + ).exitCode(); + } + } + (z.usage = C.Command.Usage({ + description: 'display the current configuration', + details: + '\n This command prints the current active configuration settings.\n ', + examples: [['Print the active configuration settings', '$0 config']], + })), + (0, a.gn)( + [ + C.Command.Boolean('-v,--verbose', { + description: + 'Print the setting description on top of the regular key/value information', + }), + ], + z.prototype, + 'verbose', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--why', { + description: + 'Print the reason why a setting is set a particular way', + }), + ], + z.prototype, + 'why', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + z.prototype, + 'json', + void 0 + ), + (0, a.gn)([C.Command.Path('config')], z.prototype, 'execute', null); + var W, + V = r(15966), + X = r(35691), + _ = r(2401), + Z = r.n(_); + !(function (e) { + e.HIGHEST = 'highest'; + })(W || (W = {})); + const $ = new Set(Object.values(W)), + ee = { + highest: async ( + e, + t, + { resolver: r, fetcher: A, resolveOptions: n, fetchOptions: o } + ) => { + const i = new Map(); + for (const [t, r] of e.storedResolutions) { + const A = e.storedDescriptors.get(t); + if (void 0 === A) + throw new Error( + `Assertion failed: The descriptor (${t}) should have been registered` + ); + P.getSetWithDefault(i, A.identHash).add(r); + } + return Array.from(e.storedDescriptors.values(), async (A) => { + if (t.length && !Z().isMatch(d.stringifyIdent(A), t)) + return null; + const o = e.storedResolutions.get(A.descriptorHash); + if (void 0 === o) + throw new Error( + `Assertion failed: The resolution (${A.descriptorHash}) should have been registered` + ); + const s = e.originalPackages.get(o); + if (void 0 === s) return null; + if (!r.shouldPersistResolution(s, n)) return null; + const a = i.get(A.identHash); + if (void 0 === a) + throw new Error( + `Assertion failed: The resolutions (${A.identHash}) should have been registered` + ); + if (1 === a.size) return null; + const c = [...a].map((t) => { + const r = e.originalPackages.get(t); + if (void 0 === r) + throw new Error( + `Assertion failed: The package (${t}) should have been registered` + ); + return r.reference; + }), + g = await r.getSatisfying(A, c, n), + l = null == g ? void 0 : g[0]; + if (void 0 === l) return null; + const u = l.locatorHash, + h = e.originalPackages.get(u); + if (void 0 === h) + throw new Error( + `Assertion failed: The package (${u}) should have been registered` + ); + return u === o + ? null + : { descriptor: A, currentPackage: s, updatedPackage: h }; + }); + }, + }; + class te extends c.BaseCommand { + constructor() { + super(...arguments), + (this.patterns = []), + (this.strategy = W.HIGHEST), + (this.check = !1), + (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await h.I.find(e, this.context.cwd), + r = await g.C.find(e); + let A = 0; + const n = await p.Pk.start( + { + configuration: e, + includeFooter: !1, + stdout: this.context.stdout, + json: this.json, + }, + async (e) => { + A = await (async function ( + e, + { strategy: t, patterns: r, cache: A, report: n } + ) { + const { configuration: o } = e, + i = new I.$(), + s = o.makeResolver(), + a = o.makeFetcher(), + c = { + cache: A, + checksums: e.storedChecksums, + fetcher: a, + project: e, + report: i, + skipIntegrityCheck: !0, + }, + g = { project: e, resolver: s, report: i, fetchOptions: c }; + return await n.startTimerPromise( + 'Deduplication step', + async () => { + const A = ee[t], + i = await A(e, r, { + resolver: s, + resolveOptions: g, + fetcher: a, + fetchOptions: c, + }), + l = X.yG.progressViaCounter(i.length); + n.reportProgress(l); + let h, + p = 0; + switch ( + (await Promise.all( + i.map((t) => + t + .then((t) => { + if (null === t) return; + p++; + const { + descriptor: r, + currentPackage: A, + updatedPackage: i, + } = t; + n.reportInfo( + u.b.UNNAMED, + `${d.prettyDescriptor( + o, + r + )} can be deduped from ${d.prettyLocator( + o, + A + )} to ${d.prettyLocator(o, i)}` + ), + n.reportJson({ + descriptor: d.stringifyDescriptor(r), + currentResolution: d.stringifyLocator(A), + updatedResolution: d.stringifyLocator(i), + }), + e.storedResolutions.set( + r.descriptorHash, + i.locatorHash + ); + }) + .finally(() => l.tick()) + ) + ), + p) + ) { + case 0: + h = 'No packages'; + break; + case 1: + h = 'One package'; + break; + default: + h = p + ' packages'; + } + const C = B.pretty(o, t, B.Type.CODE); + return ( + n.reportInfo( + u.b.UNNAMED, + `${h} can be deduped using the ${C} strategy` + ), + p + ); + } + ); + })(t, { + strategy: this.strategy, + patterns: this.patterns, + cache: r, + report: e, + }); + } + ); + if (n.hasErrors()) return n.exitCode(); + if (this.check) return A ? 1 : 0; + return ( + await p.Pk.start( + { + configuration: e, + stdout: this.context.stdout, + json: this.json, + }, + async (e) => { + await t.install({ cache: r, report: e }); + } + ) + ).exitCode(); + } + } + (te.schema = V.object().shape({ + strategy: V.string().test({ + name: 'strategy', + message: '${path} must be one of ${strategies}', + params: { strategies: [...$].join(', ') }, + test: (e) => $.has(e), + }), + })), + (te.usage = C.Command.Usage({ + description: 'deduplicate dependencies with overlapping ranges', + details: + "\n Duplicates are defined as descriptors with overlapping ranges being resolved and locked to different locators. They are a natural consequence of Yarn's deterministic installs, but they can sometimes pile up and unnecessarily increase the size of your project.\n\n This command dedupes dependencies in the current project using different strategies (only one is implemented at the moment):\n\n - `highest`: Reuses (where possible) the locators with the highest versions. This means that dependencies can only be upgraded, never downgraded. It's also guaranteed that it never takes more than a single pass to dedupe the entire dependency tree.\n\n **Note:** Even though it never produces a wrong dependency tree, this command should be used with caution, as it modifies the dependency tree, which can sometimes cause problems when packages don't strictly follow semver recommendations. Because of this, it is recommended to also review the changes manually.\n\n If set, the `-c,--check` flag will only report the found duplicates, without persisting the modified dependency tree. If changes are found, the command will exit with a non-zero exit code, making it suitable for CI purposes.\n\n This command accepts glob patterns as arguments (if valid Idents and supported by [micromatch](https://github.com/micromatch/micromatch)). Make sure to escape the patterns, to prevent your own shell from trying to expand them.\n\n ### In-depth explanation:\n\n Yarn doesn't deduplicate dependencies by default, otherwise installs wouldn't be deterministic and the lockfile would be useless. What it actually does is that it tries to not duplicate dependencies in the first place.\n\n **Example:** If `foo@^2.3.4` (a dependency of a dependency) has already been resolved to `foo@2.3.4`, running `yarn add foo@*`will cause Yarn to reuse `foo@2.3.4`, even if the latest `foo` is actually `foo@2.10.14`, thus preventing unnecessary duplication.\n\n Duplication happens when Yarn can't unlock dependencies that have already been locked inside the lockfile.\n\n **Example:** If `foo@^2.3.4` (a dependency of a dependency) has already been resolved to `foo@2.3.4`, running `yarn add foo@2.10.14` will cause Yarn to install `foo@2.10.14` because the existing resolution doesn't satisfy the range `2.10.14`. This behavior can lead to (sometimes) unwanted duplication, since now the lockfile contains 2 separate resolutions for the 2 `foo` descriptors, even though they have overlapping ranges, which means that the lockfile can be simplified so that both descriptors resolve to `foo@2.10.14`.\n ", + examples: [ + ['Dedupe all packages', '$0 dedupe'], + [ + 'Dedupe all packages using a specific strategy', + '$0 dedupe --strategy highest', + ], + ['Dedupe a specific package', '$0 dedupe lodash'], + [ + 'Dedupe all packages with the `@babel/*` scope', + "$0 dedupe '@babel/*'", + ], + [ + 'Check for duplicates (can be used as a CI step)', + '$0 dedupe --check', + ], + ], + })), + (0, a.gn)([C.Command.Rest()], te.prototype, 'patterns', void 0), + (0, a.gn)( + [ + C.Command.String('-s,--strategy', { + description: 'The strategy to use when deduping dependencies', + }), + ], + te.prototype, + 'strategy', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-c,--check', { + description: + 'Exit with exit code 1 when duplicates are found, without persisting the dependency tree', + }), + ], + te.prototype, + 'check', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + te.prototype, + 'json', + void 0 + ), + (0, a.gn)([C.Command.Path('dedupe')], te.prototype, 'execute', null); + class re extends C.Command { + async execute() { + const { plugins: e } = await s.VK.find( + this.context.cwd, + this.context.plugins + ), + t = []; + for (const r of e) { + const { commands: e } = r[1]; + if (e) { + const A = C.Cli.from(e).definitions(); + t.push([r[0], A]); + } + } + const A = this.cli.definitions(), + n = r(60306)['@yarnpkg/builder'].bundles.standard; + for (const e of t) { + const t = e[1]; + for (const r of t) + A.find((e) => { + return ( + (t = e.path), + (A = r.path), + t.split(' ').slice(1).join() === + A.split(' ').slice(1).join() + ); + var t, A; + }).plugin = { name: e[0], isDefault: n.includes(e[0]) }; + } + this.context.stdout.write( + JSON.stringify({ commands: A }, null, 2) + '\n' + ); + } + } + (0, a.gn)( + [C.Command.Path('--clipanion=definitions')], + re.prototype, + 'execute', + null + ); + class Ae extends C.Command { + async execute() { + this.context.stdout.write(this.cli.usage(null)); + } + } + (0, a.gn)( + [ + C.Command.Path('help'), + C.Command.Path('--help'), + C.Command.Path('-h'), + ], + Ae.prototype, + 'execute', + null + ); + class ne extends C.Command { + constructor() { + super(...arguments), (this.args = []); + } + async execute() { + if ( + this.leadingArgument.match(/[\\/]/) && + !d.tryParseIdent(this.leadingArgument) + ) { + const e = m.y1.resolve( + this.context.cwd, + m.cS.toPortablePath(this.leadingArgument) + ); + return await this.cli.run(this.args, { cwd: e }); + } + return await this.cli.run([ + 'run', + this.leadingArgument, + ...this.args, + ]); + } + } + (0, a.gn)( + [C.Command.String()], + ne.prototype, + 'leadingArgument', + void 0 + ), + (0, a.gn)([C.Command.Proxy()], ne.prototype, 'args', void 0); + var oe = r(59355); + class ie extends C.Command { + async execute() { + this.context.stdout.write((oe.o || '') + '\n'); + } + } + (0, a.gn)( + [C.Command.Path('-v'), C.Command.Path('--version')], + ie.prototype, + 'execute', + null + ); + var se = r(6220); + class ae extends c.BaseCommand { + constructor() { + super(...arguments), (this.args = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await h.I.find(e, this.context.cwd); + return await y.xfs.mktempPromise(async (e) => { + const { code: r } = await se.pipevp(this.commandName, this.args, { + cwd: this.context.cwd, + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + env: await R.makeScriptEnv({ project: t, binFolder: e }), + }); + return r; + }); + } + } + (ae.usage = C.Command.Usage({ + description: 'execute a shell command', + details: + "\n This command simply executes a shell binary within the context of the root directory of the active workspace.\n\n It also makes sure to call it in a way that's compatible with the current project (for example, on PnP projects the environment will be setup in such a way that PnP will be correctly injected into the environment).\n ", + examples: [['Execute a shell command', '$0 exec echo Hello World']], + })), + (0, a.gn)([C.Command.String()], ae.prototype, 'commandName', void 0), + (0, a.gn)([C.Command.Proxy()], ae.prototype, 'args', void 0), + (0, a.gn)([C.Command.Path('exec')], ae.prototype, 'execute', null); + var ce = r(36545); + class ge extends c.BaseCommand { + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await h.I.find(e, this.context.cwd); + if ((await t.applyLightResolution(), void 0 !== this.hash)) + return await (async function (e, t, r) { + const { configuration: A } = t, + n = t.peerRequirements.get(e); + if (void 0 === n) + throw new Error( + `No peerDependency requirements found for hash: "${e}"` + ); + return ( + await p.Pk.start( + { configuration: A, stdout: r.stdout, includeFooter: !1 }, + async (e) => { + var r, o; + const i = t.storedPackages.get(n.subject); + if (void 0 === i) + throw new Error( + 'Assertion failed: Expected the subject package to have been registered' + ); + const s = t.storedPackages.get(n.rootRequester); + if (void 0 === s) + throw new Error( + 'Assertion failed: Expected the root package to have been registered' + ); + const a = + null !== + (r = i.dependencies.get(n.requested.identHash)) && + void 0 !== r + ? r + : null, + c = + null !== a + ? t.storedResolutions.get(a.descriptorHash) + : null; + if (void 0 === c) + throw new Error( + 'Assertion failed: Expected the resolution to have been registered' + ); + const g = null !== c ? t.storedPackages.get(c) : null; + if (void 0 === g) + throw new Error( + 'Assertion failed: Expected the provided package to have been registered' + ); + const l = [...n.allRequesters.values()].map((e) => { + const r = t.storedPackages.get(e); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the package to be registered' + ); + const A = d.devirtualizeLocator(r), + o = t.storedPackages.get(A.locatorHash); + if (void 0 === o) + throw new Error( + 'Assertion failed: Expected the package to be registered' + ); + const i = o.peerDependencies.get(n.requested.identHash); + if (void 0 === i) + throw new Error( + 'Assertion failed: Expected the peer dependency to be registered' + ); + return { pkg: r, peerDependency: i }; + }); + if (null !== g) { + const t = l.every(({ peerDependency: e }) => + ce.satisfiesWithPrereleases(g.version, e.range) + ); + e.reportInfo( + u.b.UNNAMED, + `${d.prettyLocator(A, i)} provides ${d.prettyLocator( + A, + g + )} with version ${d.prettyReference( + A, + null !== (o = g.version) && void 0 !== o + ? o + : '' + )}, which ${ + t ? 'satisfies' : "doesn't satisfy" + } the following requirements:` + ); + } else + e.reportInfo( + u.b.UNNAMED, + `${d.prettyLocator( + A, + i + )} doesn't provide ${d.prettyIdent( + A, + n.requested + )}, breaking the following requirements:` + ); + e.reportSeparator(); + const h = B.mark(A), + p = []; + for (const { pkg: e, peerDependency: t } of P.sortMap( + l, + (e) => d.stringifyLocator(e.pkg) + )) { + const r = + null !== g && + ce.satisfiesWithPrereleases(g.version, t.range) + ? h.Check + : h.Cross; + p.push({ + stringifiedLocator: d.stringifyLocator(e), + prettyLocator: d.prettyLocator(A, e), + prettyRange: d.prettyRange(A, t.range), + mark: r, + }); + } + const C = Math.max( + ...p.map(({ stringifiedLocator: e }) => e.length) + ), + f = Math.max( + ...p.map(({ prettyRange: e }) => e.length) + ); + for (const { + stringifiedLocator: t, + prettyLocator: r, + prettyRange: A, + mark: n, + } of P.sortMap(p, ({ stringifiedLocator: e }) => e)) + e.reportInfo( + null, + `${r.padEnd( + C + (r.length - t.length), + ' ' + )} → ${A.padEnd(f, ' ')} ${n}` + ); + p.length > 1 && + (e.reportSeparator(), + e.reportInfo( + u.b.UNNAMED, + 'Note: these requirements start with ' + + d.prettyLocator(t.configuration, s) + )); + } + ) + ).exitCode(); + })(this.hash, t, { stdout: this.context.stdout }); + return ( + await p.Pk.start( + { + configuration: e, + stdout: this.context.stdout, + includeFooter: !1, + }, + async (r) => { + var A; + const n = [ + ([, e]) => + d.stringifyLocator(t.storedPackages.get(e.subject)), + ([, e]) => d.stringifyIdent(e.requested), + ]; + for (const [o, i] of P.sortMap(t.peerRequirements, n)) { + const n = t.storedPackages.get(i.subject); + if (void 0 === n) + throw new Error( + 'Assertion failed: Expected the subject package to have been registered' + ); + const s = t.storedPackages.get(i.rootRequester); + if (void 0 === s) + throw new Error( + 'Assertion failed: Expected the root package to have been registered' + ); + const a = + null !== + (A = n.dependencies.get(i.requested.identHash)) && + void 0 !== A + ? A + : null, + c = B.pretty(e, o, B.Type.CODE), + g = d.prettyLocator(e, n), + l = d.prettyIdent(e, i.requested), + u = d.prettyIdent(e, s), + h = i.allRequesters.length - 1, + p = 'descendant' + (1 === h ? '' : 's'), + C = h > 0 ? ` and ${h} ${p}` : '', + f = null !== a ? 'provides' : "doesn't provide"; + r.reportInfo(null, `${c} → ${g} ${f} ${l} to ${u}${C}`); + } + } + ) + ).exitCode(); + } + } + (ge.schema = V.object().shape({ + hash: V.string().matches(/^p[0-9a-f]{5}$/), + })), + (ge.usage = C.Command.Usage({ + description: 'explain a set of peer requirements', + details: + "\n A set of peer requirements represents all peer requirements that a dependent must satisfy when providing a given peer request to a requester and its descendants.\n\n When the hash argument is specified, this command prints a detailed explanation of all requirements of the set corresponding to the hash and whether they're satisfied or not.\n\n When used without arguments, this command lists all sets of peer requirements and the corresponding hash that can be used to get detailed information about a given set.\n\n **Note:** A hash is a six-letter p-prefixed code that can be obtained from peer dependency warnings or from the list of all peer requirements (`yarn explain peer-requirements`).\n ", + examples: [ + [ + 'Explain the corresponding set of peer requirements for a hash', + '$0 explain peer-requirements p1a4ed', + ], + [ + 'List all sets of peer requirements', + '$0 explain peer-requirements', + ], + ], + })), + (0, a.gn)( + [C.Command.String({ required: !1 })], + ge.prototype, + 'hash', + void 0 + ), + (0, a.gn)( + [C.Command.Path('explain', 'peer-requirements')], + ge.prototype, + 'execute', + null + ); + var le = r(85875); + class ue extends c.BaseCommand { + constructor() { + super(...arguments), + (this.all = !1), + (this.recursive = !1), + (this.extra = []), + (this.cache = !1), + (this.dependents = !1), + (this.manifest = !1), + (this.nameOnly = !1), + (this.virtuals = !1), + (this.json = !1), + (this.patterns = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ), + A = await g.C.find(e); + if (!r && !this.all) + throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState(); + const n = new Set(this.extra); + this.cache && n.add('cache'), + this.dependents && n.add('dependents'), + this.manifest && n.add('manifest'); + const o = (e, { recursive: r }) => { + const A = e.anchoredLocator.locatorHash, + n = new Map(), + o = [A]; + for (; o.length > 0; ) { + const e = o.shift(); + if (n.has(e)) continue; + const i = t.storedPackages.get(e); + if (void 0 === i) + throw new Error( + 'Assertion failed: Expected the package to be registered' + ); + if ( + (n.set(e, i), + d.isVirtualLocator(i) && + o.push(d.devirtualizeLocator(i).locatorHash), + r || e === A) + ) + for (const e of i.dependencies.values()) { + const r = t.storedResolutions.get(e.descriptorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the resolution to be registered' + ); + o.push(r); + } + } + return n.values(); + }, + i = ({ all: e, recursive: A }) => + e && A + ? t.storedPackages.values() + : e + ? (({ recursive: e }) => { + const r = new Map(); + for (const A of t.workspaces) + for (const t of o(A, { recursive: e })) + r.set(t.locatorHash, t); + return r.values(); + })({ recursive: A }) + : o(r, { recursive: A }), + { selection: a, sortedLookup: l } = (({ + all: e, + recursive: t, + }) => { + const r = i({ all: e, recursive: t }), + A = this.patterns.map((e) => { + const t = d.parseLocator(e), + r = Z().makeRe(d.stringifyIdent(t)), + A = d.isVirtualLocator(t), + n = A ? d.devirtualizeLocator(t) : t; + return (e) => { + const o = d.stringifyIdent(e); + if (!r.test(o)) return !1; + if ('unknown' === t.reference) return !0; + const i = d.isVirtualLocator(e), + s = i ? d.devirtualizeLocator(e) : e; + return ( + (!A || !i || t.reference === e.reference) && + n.reference === s.reference + ); + }; + }), + n = P.sortMap([...r], (e) => d.stringifyLocator(e)); + return { + selection: n.filter( + (e) => 0 === A.length || A.some((t) => t(e)) + ), + sortedLookup: n, + }; + })({ all: this.all, recursive: this.recursive }); + if (0 === a.length) + throw new C.UsageError('No package matched your request'); + const u = new Map(); + if (this.dependents) + for (const e of l) + for (const r of e.dependencies.values()) { + const A = t.storedResolutions.get(r.descriptorHash); + if (void 0 === A) + throw new Error( + 'Assertion failed: Expected the resolution to be registered' + ); + P.getArrayWithDefault(u, A).push(e); + } + const p = new Map(); + for (const e of l) { + if (!d.isVirtualLocator(e)) continue; + const t = d.devirtualizeLocator(e); + P.getArrayWithDefault(p, t.locatorHash).push(e); + } + const f = {}, + m = { children: f }, + w = e.makeFetcher(), + Q = { + project: t, + fetcher: w, + cache: A, + checksums: t.storedChecksums, + report: new I.$(), + skipIntegrityCheck: !0, + }, + D = [ + async (e, t, r) => { + var A, n; + if (!t.has('manifest')) return; + const o = await w.fetch(e, Q); + let i; + try { + i = await E.G.find(o.prefixPath, { baseFs: o.packageFs }); + } finally { + null === (A = o.releaseFs) || void 0 === A || A.call(o); + } + r('Manifest', { + License: B.tuple(B.Type.NO_HINT, i.license), + Homepage: B.tuple( + B.Type.URL, + null !== (n = i.raw.homepage) && void 0 !== n ? n : null + ), + }); + }, + async (e, r, n) => { + var o; + if (!r.has('cache')) return; + const i = + null !== (o = t.storedChecksums.get(e.locatorHash)) && + void 0 !== o + ? o + : null, + s = A.getLocatorPath(e, i); + let a; + if (null !== s) + try { + a = y.xfs.statSync(s); + } catch (e) {} + const c = void 0 !== a ? [a.size, B.Type.SIZE] : void 0; + n('Cache', { + Checksum: B.tuple(B.Type.NO_HINT, i), + Path: B.tuple(B.Type.PATH, s), + Size: c, + }); + }, + ]; + for (const r of a) { + const A = d.isVirtualLocator(r); + if (!this.virtuals && A) continue; + const o = {}, + i = { value: [r, B.Type.LOCATOR], children: o }; + if (((f[d.stringifyLocator(r)] = i), this.nameOnly)) { + delete i.children; + continue; + } + const s = p.get(r.locatorHash); + void 0 !== s && + (o.Instances = { + label: 'Instances', + value: B.tuple(B.Type.NUMBER, s.length), + }), + (o.Version = { + label: 'Version', + value: B.tuple(B.Type.NO_HINT, r.version), + }); + const a = (e, t) => { + const r = {}; + if (((o[e] = r), Array.isArray(t))) + r.children = t.map((e) => ({ value: e })); + else { + const e = {}; + r.children = e; + for (const [r, A] of Object.entries(t)) + void 0 !== A && (e[r] = { label: r, value: A }); + } + }; + if (!A) { + for (const e of D) await e(r, n, a); + await e.triggerHook((e) => e.fetchPackageInfo, r, n, a); + } + r.bin.size > 0 && + !A && + a( + 'Exported Binaries', + [...r.bin.keys()].map((e) => B.tuple(B.Type.PATH, e)) + ); + const c = u.get(r.locatorHash); + void 0 !== c && + c.length > 0 && + a( + 'Dependents', + c.map((e) => B.tuple(B.Type.LOCATOR, e)) + ), + r.dependencies.size > 0 && + !A && + a( + 'Dependencies', + [...r.dependencies.values()].map((e) => { + var r; + const A = t.storedResolutions.get(e.descriptorHash), + n = + void 0 !== A && + null !== (r = t.storedPackages.get(A)) && + void 0 !== r + ? r + : null; + return B.tuple(B.Type.RESOLUTION, { + descriptor: e, + locator: n, + }); + }) + ), + r.peerDependencies.size > 0 && + A && + a( + 'Peer dependencies', + [...r.peerDependencies.values()].map((e) => { + var A, n; + const o = r.dependencies.get(e.identHash), + i = + void 0 !== o && + null !== + (A = t.storedResolutions.get(o.descriptorHash)) && + void 0 !== A + ? A + : null, + s = + null !== i && + null !== (n = t.storedPackages.get(i)) && + void 0 !== n + ? n + : null; + return B.tuple(B.Type.RESOLUTION, { + descriptor: e, + locator: s, + }); + }) + ); + } + le.emitTree(m, { + configuration: e, + json: this.json, + stdout: this.context.stdout, + separators: this.nameOnly ? 0 : 2, + }); + } + } + (ue.usage = C.Command.Usage({ + description: 'see information related to packages', + details: + '\n This command prints various information related to the specified packages, accepting glob patterns.\n\n By default, if the locator reference is missing, Yarn will default to print the information about all the matching direct dependencies of the package for the active workspace. To instead print all versions of the package that are direct dependencies of any of your workspaces, use the `-A,--all` flag. Adding the `-R,--recursive` flag will also report transitive dependencies.\n\n Some fields will be hidden by default in order to keep the output readable, but can be selectively displayed by using additional options (`--dependents`, `--manifest`, `--virtuals`, ...) described in the option descriptions.\n\n Note that this command will only print the information directly related to the selected packages - if you wish to know why the package is there in the first place, use `yarn why` which will do just that (it also provides a `-R,--recursive` flag that may be of some help).\n ', + examples: [['Show information about Lodash', '$0 info lodash']], + })), + (0, a.gn)( + [ + C.Command.Boolean('-A,--all', { + description: + 'Print versions of a package from the whole project', + }), + ], + ue.prototype, + 'all', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-R,--recursive', { + description: + 'Print information for all packages, including transitive dependencies', + }), + ], + ue.prototype, + 'recursive', + void 0 + ), + (0, a.gn)( + [ + C.Command.Array('-X,--extra', { + description: + 'An array of requests of extra data provided by plugins', + }), + ], + ue.prototype, + 'extra', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--cache', { + description: + 'Print information about the cache entry of a package (path, size, checksum)', + }), + ], + ue.prototype, + 'cache', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--dependents', { + description: 'Print all dependents for each matching package', + }), + ], + ue.prototype, + 'dependents', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--manifest', { + description: + 'Print data obtained by looking at the package archive (license, homepage, ...)', + }), + ], + ue.prototype, + 'manifest', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--name-only', { + description: 'Only print the name for the matching packages', + }), + ], + ue.prototype, + 'nameOnly', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--virtuals', { + description: 'Print each instance of the virtual packages', + }), + ], + ue.prototype, + 'virtuals', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + ue.prototype, + 'json', + void 0 + ), + (0, a.gn)([C.Command.Rest()], ue.prototype, 'patterns', void 0), + (0, a.gn)([C.Command.Path('info')], ue.prototype, 'execute', null); + var he = r(11640), + pe = r(5864); + class de extends c.BaseCommand { + constructor() { + super(...arguments), + (this.json = !1), + (this.checkCache = !1), + (this.skipBuilds = !1), + (this.silent = !1); + } + async execute() { + var e, t, r; + const A = await s.VK.find(this.context.cwd, this.context.plugins); + void 0 !== this.inlineBuilds && + A.useWithSource( + '', + { enableInlineBuilds: this.inlineBuilds }, + A.startingCwd, + { overwrite: !0 } + ); + const n = !!process.env.NOW_BUILDER, + o = !!process.env.NETLIFY, + i = !!process.env.FUNCTION_TARGET || !!process.env.GOOGLE_RUNTIME, + a = async (e, { error: t }) => { + const r = await p.Pk.start( + { + configuration: A, + stdout: this.context.stdout, + includeFooter: !1, + }, + async (r) => { + t + ? r.reportError(u.b.DEPRECATED_CLI_SETTINGS, e) + : r.reportWarning(u.b.DEPRECATED_CLI_SETTINGS, e); + } + ); + return r.hasErrors() ? r.exitCode() : null; + }; + if (void 0 !== this.ignoreEngines) { + const e = await a( + "The --ignore-engines option is deprecated; engine checking isn't a core feature anymore", + { error: !n } + ); + if (null !== e) return e; + } + if (void 0 !== this.registry) { + const e = await a( + 'The --registry option is deprecated; prefer setting npmRegistryServer in your .yarnrc.yml file', + { error: !1 } + ); + if (null !== e) return e; + } + if (void 0 !== this.preferOffline) { + const e = await a( + "The --prefer-offline flag is deprecated; use the --cached flag with 'yarn add' instead", + { error: !n } + ); + if (null !== e) return e; + } + if (void 0 !== this.production) { + const e = await a( + "The --production option is deprecated on 'install'; use 'yarn workspaces focus' instead", + { error: !0 } + ); + if (null !== e) return e; + } + if (void 0 !== this.nonInteractive) { + const e = await a('The --non-interactive option is deprecated', { + error: !i, + }); + if (null !== e) return e; + } + if (void 0 !== this.frozenLockfile) { + const e = await a( + 'The --frozen-lockfile option is deprecated; use --immutable and/or --immutable-cache instead', + { error: !i && !pe.TRAVIS } + ); + if (null !== e) return e; + } + if (void 0 !== this.cacheFolder) { + const e = await a( + 'The cache-folder option has been deprecated; use rc settings instead', + { error: !o } + ); + if (null !== e) return e; + } + const l = + void 0 === this.immutable && void 0 === this.frozenLockfile + ? null !== (e = A.get('enableImmutableInstalls')) && + void 0 !== e && + e + : null !== + (r = + null !== (t = this.immutable) && void 0 !== t + ? t + : this.frozenLockfile) && + void 0 !== r && + r; + if (null !== A.projectCwd) { + const e = await p.Pk.start( + { + configuration: A, + json: this.json, + stdout: this.context.stdout, + includeFooter: !1, + }, + async (e) => { + (await (async function (e, t) { + if (!e.projectCwd) return !1; + const r = m.y1.join( + e.projectCwd, + e.get('lockfileFilename') + ); + if (!(await y.xfs.existsPromise(r))) return !1; + const A = await y.xfs.readFilePromise(r, 'utf8'); + if (!A.includes('<<<<<<<')) return !1; + if (t) + throw new X.lk( + u.b.AUTOMERGE_IMMUTABLE, + 'Cannot autofix a lockfile when running an immutable install' + ); + const [n, o] = (function (e) { + const t = [[], []], + r = e.split(/\r?\n/g); + let A = !1; + for (; r.length > 0; ) { + const e = r.shift(); + if (void 0 === e) + throw new Error( + 'Assertion failed: Some lines should remain' + ); + if (e.startsWith('<<<<<<<')) { + for (; r.length > 0; ) { + const e = r.shift(); + if (void 0 === e) + throw new Error( + 'Assertion failed: Some lines should remain' + ); + if ('=======' === e) { + A = !1; + break; + } + A || e.startsWith('|||||||') + ? (A = !0) + : t[0].push(e); + } + for (; r.length > 0; ) { + const e = r.shift(); + if (void 0 === e) + throw new Error( + 'Assertion failed: Some lines should remain' + ); + if (e.startsWith('>>>>>>>')) break; + t[1].push(e); + } + } else t[0].push(e), t[1].push(e); + } + return [t[0].join('\n'), t[1].join('\n')]; + })(A); + let i, s; + try { + (i = (0, he.parseSyml)(n)), (s = (0, he.parseSyml)(o)); + } catch (e) { + throw new X.lk( + u.b.AUTOMERGE_FAILED_TO_PARSE, + 'The individual variants of the lockfile failed to parse' + ); + } + const a = { ...i, ...s }; + for (const [e, t] of Object.entries(a)) + 'string' == typeof t && delete a[e]; + return ( + await y.xfs.changeFilePromise( + r, + (0, he.stringifySyml)(a), + { automaticNewlines: !0 } + ), + !0 + ); + })(A, l)) && + (e.reportInfo( + u.b.AUTOMERGE_SUCCESS, + 'Automatically fixed merge conflicts 👍' + ), + e.reportSeparator()); + } + ); + if (e.hasErrors()) return e.exitCode(); + } + if (null !== A.projectCwd) { + const e = await p.Pk.start( + { + configuration: A, + json: this.json, + stdout: this.context.stdout, + includeFooter: !1, + }, + async (e) => { + var t; + (null === (t = s.VK.telemetry) || void 0 === t + ? void 0 + : t.isNew) && + (e.reportInfo( + u.b.TELEMETRY_NOTICE, + 'Yarn will periodically gather anonymous telemetry: https://yarnpkg.com/advanced/telemetry' + ), + e.reportInfo( + u.b.TELEMETRY_NOTICE, + `Run ${B.pretty( + A, + 'yarn config set --home enableTelemetry 0', + B.Type.CODE + )} to disable` + ), + e.reportSeparator()); + } + ); + if (e.hasErrors()) return e.exitCode(); + } + const { project: d, workspace: C } = await h.I.find( + A, + this.context.cwd + ), + f = await g.C.find(A, { + immutable: this.immutableCache, + check: this.checkCache, + }); + if (!C) throw new c.WorkspaceRequiredError(d.cwd, this.context.cwd); + await d.restoreInstallState({ restoreResolutions: !1 }); + return ( + await p.Pk.start( + { + configuration: A, + json: this.json, + stdout: this.context.stdout, + includeLogs: !0, + }, + async (e) => { + await d.install({ + cache: f, + report: e, + immutable: l, + skipBuild: this.skipBuilds, + }); + } + ) + ).exitCode(); + } + } + (de.usage = C.Command.Usage({ + description: 'install the project dependencies', + details: + "\n This command setup your project if needed. The installation is splitted in four different steps that each have their own characteristics:\n\n - **Resolution:** First the package manager will resolve your dependencies. The exact way a dependency version is privileged over another isn't standardized outside of the regular semver guarantees. If a package doesn't resolve to what you would expect, check that all dependencies are correctly declared (also check our website for more information: ).\n\n - **Fetch:** Then we download all the dependencies if needed, and make sure that they're all stored within our cache (check the value of `cacheFolder` in `yarn config` to see where are stored the cache files).\n\n - **Link:** Then we send the dependency tree information to internal plugins tasked from writing them on the disk in some form (for example by generating the .pnp.js file you might know).\n\n - **Build:** Once the dependency tree has been written on the disk, the package manager will now be free to run the build scripts for all packages that might need it, in a topological order compatible with the way they depend on one another.\n\n Note that running this command is not part of the recommended workflow. Yarn supports zero-installs, which means that as long as you store your cache and your .pnp.js file inside your repository, everything will work without requiring any install right after cloning your repository or switching branches.\n\n If the `--immutable` option is set, Yarn will abort with an error exit code if the lockfile was to be modified (other paths can be added using the `immutablePaths` configuration setting). For backward compatibility we offer an alias under the name of `--frozen-lockfile`, but it will be removed in a later release.\n\n If the `--immutable-cache` option is set, Yarn will abort with an error exit code if the cache folder was to be modified (either because files would be added, or because they'd be removed).\n\n If the `--check-cache` option is set, Yarn will always refetch the packages and will ensure that their checksum matches what's 1/ described in the lockfile 2/ inside the existing cache files (if present). This is recommended as part of your CI workflow if you're both following the Zero-Installs model and accepting PRs from third-parties, as they'd otherwise have the ability to alter the checked-in packages before submitting them.\n\n If the `--inline-builds` option is set, Yarn will verbosely print the output of the build steps of your dependencies (instead of writing them into individual files). This is likely useful mostly for debug purposes only when using Docker-like environments.\n\n If the `--skip-builds` option is set, Yarn will not run the build scripts at all. Note that this is different from setting `enableScripts` to false because the later will disable build scripts, and thus affect the content of the artifacts generated on disk, whereas the former will just disable the build step - but not the scripts themselves, which just won't run.\n ", + examples: [ + ['Install the project', '$0 install'], + [ + 'Validate a project when using Zero-Installs', + '$0 install --immutable --immutable-cache', + ], + [ + 'Validate a project when using Zero-Installs (slightly safer if you accept external PRs)', + '$0 install --immutable --immutable-cache --check-cache', + ], + ], + })), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + de.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--immutable', { + description: + 'Abort with an error exit code if the lockfile was to be modified', + }), + ], + de.prototype, + 'immutable', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--immutable-cache', { + description: + 'Abort with an error exit code if the cache folder was to be modified', + }), + ], + de.prototype, + 'immutableCache', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--check-cache', { + description: + 'Always refetch the packages and ensure that their checksums are consistent', + }), + ], + de.prototype, + 'checkCache', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--production', { hidden: !0 })], + de.prototype, + 'production', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--non-interactive', { hidden: !0 })], + de.prototype, + 'nonInteractive', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--frozen-lockfile', { hidden: !0 })], + de.prototype, + 'frozenLockfile', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--prefer-offline', { hidden: !0 })], + de.prototype, + 'preferOffline', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--ignore-engines', { hidden: !0 })], + de.prototype, + 'ignoreEngines', + void 0 + ), + (0, a.gn)( + [C.Command.String('--registry', { hidden: !0 })], + de.prototype, + 'registry', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--inline-builds', { + description: + 'Verbosely print the output of the build steps of dependencies', + }), + ], + de.prototype, + 'inlineBuilds', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--skip-builds', { + description: 'Skip the build step altogether', + }), + ], + de.prototype, + 'skipBuilds', + void 0 + ), + (0, a.gn)( + [C.Command.String('--cache-folder', { hidden: !0 })], + de.prototype, + 'cacheFolder', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--silent', { hidden: !0 })], + de.prototype, + 'silent', + void 0 + ), + (0, a.gn)( + [C.Command.Path(), C.Command.Path('install')], + de.prototype, + 'execute', + null + ); + class Ce extends c.BaseCommand { + constructor() { + super(...arguments), + (this.all = !1), + (this.private = !1), + (this.relative = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ), + A = await g.C.find(e); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + const n = m.y1.resolve( + this.context.cwd, + m.cS.toPortablePath(this.destination) + ), + o = await s.VK.find(n, this.context.plugins), + { project: i, workspace: a } = await h.I.find(o, n); + if (!a) throw new c.WorkspaceRequiredError(i.cwd, n); + const l = t.topLevelWorkspace, + u = []; + if (this.all) { + for (const e of i.workspaces) + !e.manifest.name || + (e.manifest.private && !this.private) || + u.push(e); + if (0 === u.length) + throw new C.UsageError( + 'No workspace found to be linked in the target project' + ); + } else { + if (!a.manifest.name) + throw new C.UsageError( + "The target workspace doesn't have a name and thus cannot be linked" + ); + if (a.manifest.private && !this.private) + throw new C.UsageError( + 'The target workspace is marked private - use the --private flag to link it anyway' + ); + u.push(a); + } + for (const e of u) { + const r = d.stringifyIdent(e.locator), + A = this.relative ? m.y1.relative(t.cwd, e.cwd) : e.cwd; + l.manifest.resolutions.push({ + pattern: { descriptor: { fullName: r } }, + reference: 'portal:' + A, + }); + } + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (e) => { + await t.install({ cache: A, report: e }); + } + ) + ).exitCode(); + } + } + (Ce.usage = C.Command.Usage({ + description: 'connect the local project to another one', + details: + '\n This command will set a new `resolutions` field in the project-level manifest and point it to the workspace at the specified location (even if part of another project).\n\n There is no `yarn unlink` command. To unlink the workspaces from the current project one must revert the changes made to the `resolutions` field.\n ', + examples: [ + [ + 'Register a remote workspace for use in the current project', + '$0 link ~/ts-loader', + ], + [ + 'Register all workspaces from a remote project for use in the current project', + '$0 link ~/jest --all', + ], + ], + })), + (0, a.gn)([C.Command.String()], Ce.prototype, 'destination', void 0), + (0, a.gn)( + [ + C.Command.Boolean('-A,--all', { + description: + 'Link all workspaces belonging to the target project to the current one', + }), + ], + Ce.prototype, + 'all', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-p,--private', { + description: + 'Also link private workspaces belonging to the target project to the current one', + }), + ], + Ce.prototype, + 'private', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-r,--relative', { + description: + 'Link workspaces using relative paths instead of absolute paths', + }), + ], + Ce.prototype, + 'relative', + void 0 + ), + (0, a.gn)([C.Command.Path('link')], Ce.prototype, 'execute', null); + class fe extends c.BaseCommand { + constructor() { + super(...arguments), (this.args = []); + } + async execute() { + return this.cli.run(['exec', 'node', ...this.args]); + } + } + (fe.usage = C.Command.Usage({ + description: 'run node with the hook already setup', + details: + "\n This command simply runs Node. It also makes sure to call it in a way that's compatible with the current project (for example, on PnP projects the environment will be setup in such a way that PnP will be correctly injected into the environment).\n\n The Node process will use the exact same version of Node as the one used to run Yarn itself, which might be a good way to ensure that your commands always use a consistent Node version.\n ", + examples: [['Run a Node script', '$0 node ./my-script.js']], + })), + (0, a.gn)([C.Command.Proxy()], fe.prototype, 'args', void 0), + (0, a.gn)([C.Command.Path('node')], fe.prototype, 'execute', null); + var Ie = r(20624), + Ee = r(12087), + Be = r(85622), + ye = r.n(Be), + me = r(79669); + class we extends c.BaseCommand { + constructor() { + super(...arguments), (this.onlyIfNeeded = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins); + if (e.get('yarnPath') && this.onlyIfNeeded) return 0; + let t; + if ('latest' === this.version || 'berry' === this.version) + t = + 'https://github.com/yarnpkg/berry/raw/master/packages/yarnpkg-cli/bin/yarn.js'; + else if ('classic' === this.version) + t = 'https://nightly.yarnpkg.com/latest.js'; + else if (ce.satisfiesWithPrereleases(this.version, '>=2.0.0')) + t = `https://github.com/yarnpkg/berry/raw/%40yarnpkg/cli/${this.version}/packages/yarnpkg-cli/bin/yarn.js`; + else { + if (!ce.satisfiesWithPrereleases(this.version, '^0.x || ^1.x')) + throw Q().validRange(this.version) + ? new C.UsageError( + "Support for ranges got removed - please use the exact version you want to install, or 'latest' to get the latest build available" + ) + : new C.UsageError( + `Invalid version descriptor "${this.version}"` + ); + t = `https://github.com/yarnpkg/yarn/releases/download/v${this.version}/yarn-${this.version}.js`; + } + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + r.reportInfo( + u.b.UNNAMED, + 'Downloading ' + B.pretty(e, t, 'green') + ); + const A = await me.get(t, { configuration: e }); + await Qe(e, null, A, { report: r }); + } + ) + ).exitCode(); + } + } + async function Qe(e, t, r, { report: A }) { + const n = e.projectCwd ? e.projectCwd : e.startingCwd; + null === t && + (await y.xfs.mktempPromise(async (e) => { + const A = m.y1.join(e, 'yarn.cjs'); + await y.xfs.writeFilePromise(A, r); + const { stdout: o } = await se.execvp( + process.execPath, + [m.cS.fromPortablePath(A), '--version'], + { cwd: n, env: { ...process.env, YARN_IGNORE_PATH: '1' } } + ); + if (((t = o.trim()), !Q().valid(t))) + throw new Error('Invalid semver version'); + })); + const o = m.y1.resolve(n, '.yarn/releases'), + i = m.y1.resolve(o, `yarn-${t}.cjs`), + a = m.y1.relative(e.startingCwd, i), + c = m.y1.relative(n, i), + g = e.get('yarnPath'), + l = null === g || g.startsWith(o + '/'); + A.reportInfo( + u.b.UNNAMED, + 'Saving the new release in ' + B.pretty(e, a, 'magenta') + ), + await y.xfs.removePromise(m.y1.dirname(i)), + await y.xfs.mkdirPromise(m.y1.dirname(i), { recursive: !0 }), + await y.xfs.writeFilePromise(i, r), + await y.xfs.chmodPromise(i, 493), + l && (await s.VK.updateConfiguration(n, { yarnPath: c })); + } + (we.usage = C.Command.Usage({ + description: 'lock the Yarn version used by the project', + details: + '\n This command will download a specific release of Yarn directly from the Yarn GitHub repository, will store it inside your project, and will change the `yarnPath` settings from your project `.yarnrc.yml` file to point to the new file.\n\n A very good use case for this command is to enforce the version of Yarn used by the any single member of your team inside a same project - by doing this you ensure that you have control on Yarn upgrades and downgrades (including on your deployment servers), and get rid of most of the headaches related to someone using a slightly different version and getting a different behavior than you.\n ', + examples: [ + [ + 'Download the latest release from the Yarn repository', + '$0 set version latest', + ], + [ + 'Download the latest classic release from the Yarn repository', + '$0 set version classic', + ], + ['Download a specific Yarn 2 build', '$0 set version 2.0.0-rc.30'], + [ + 'Switch back to a specific Yarn 1 release', + '$0 set version 1.22.1', + ], + ], + })), + (0, a.gn)( + [ + C.Command.Boolean('--only-if-needed', { + description: + "Only lock the Yarn version if it isn't already locked", + }), + ], + we.prototype, + 'onlyIfNeeded', + void 0 + ), + (0, a.gn)([C.Command.String()], we.prototype, 'version', void 0), + (0, a.gn)( + [ + C.Command.Path('policies', 'set-version'), + C.Command.Path('set', 'version'), + ], + we.prototype, + 'execute', + null + ); + const De = /^[0-9]+$/; + function be(e) { + return De.test(e) ? `pull/${e}/head` : e; + } + class ve extends c.BaseCommand { + constructor() { + super(...arguments), + (this.repository = 'https://github.com/yarnpkg/berry.git'), + (this.branch = 'master'), + (this.plugins = []), + (this.noMinify = !1), + (this.force = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + t = + void 0 !== this.installPath + ? m.y1.resolve( + this.context.cwd, + m.cS.toPortablePath(this.installPath) + ) + : m.y1.resolve( + m.cS.toPortablePath((0, Ee.tmpdir)()), + 'yarnpkg-sources', + Ie.makeHash(this.repository).slice(0, 6) + ); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + await ke(this, { configuration: e, report: r, target: t }), + r.reportSeparator(), + r.reportInfo(u.b.UNNAMED, 'Building a fresh bundle'), + r.reportSeparator(), + await Se( + (({ plugins: e, noMinify: t }, r) => [ + [ + 'yarn', + 'build:cli', + ...new Array().concat( + ...e.map((e) => ['--plugin', ye().resolve(r, e)]) + ), + ...(t ? ['--no-minify'] : []), + '|', + ], + ])(this, t), + { configuration: e, context: this.context, target: t } + ), + r.reportSeparator(); + const A = m.y1.resolve( + t, + 'packages/yarnpkg-cli/bundles/yarn.js' + ), + n = await y.xfs.readFilePromise(A); + await Qe(e, 'sources', n, { report: r }); + } + ) + ).exitCode(); + } + } + async function Se(e, { configuration: t, context: r, target: A }) { + for (const [n, ...o] of e) { + const e = '|' === o[o.length - 1]; + if ((e && o.pop(), e)) + await se.pipevp(n, o, { + cwd: A, + stdin: r.stdin, + stdout: r.stdout, + stderr: r.stderr, + strict: !0, + }); + else { + r.stdout.write( + B.pretty(t, ' $ ' + [n, ...o].join(' '), 'grey') + '\n' + ); + try { + await se.execvp(n, o, { cwd: A, strict: !0 }); + } catch (e) { + throw (r.stdout.write(e.stdout || e.stack), e); + } + } + } + } + async function ke(e, { configuration: t, report: r, target: A }) { + let n = !1; + if (!e.force && y.xfs.existsSync(m.y1.join(A, '.git'))) { + r.reportInfo(u.b.UNNAMED, 'Fetching the latest commits'), + r.reportSeparator(); + try { + await Se( + (({ branch: e }) => [ + ['git', 'fetch', 'origin', be(e), '--force'], + ['git', 'reset', '--hard', 'FETCH_HEAD'], + ['git', 'clean', '-dfx'], + ])(e), + { configuration: t, context: e.context, target: A } + ), + (n = !0); + } catch (e) { + r.reportSeparator(), + r.reportWarning( + u.b.UNNAMED, + "Repository update failed; we'll try to regenerate it" + ); + } + } + n || + (r.reportInfo(u.b.UNNAMED, 'Cloning the remote repository'), + r.reportSeparator(), + await y.xfs.removePromise(A), + await y.xfs.mkdirPromise(A, { recursive: !0 }), + await Se( + (({ repository: e, branch: t }, r) => [ + ['git', 'init', m.cS.fromPortablePath(r)], + ['git', 'remote', 'add', 'origin', e], + ['git', 'fetch', 'origin', be(t)], + ['git', 'reset', '--hard', 'FETCH_HEAD'], + ])(e, A), + { configuration: t, context: e.context, target: A } + )); + } + (ve.usage = C.Command.Usage({ + description: 'build Yarn from master', + details: + '\n This command will clone the Yarn repository into a temporary folder, then build it. The resulting bundle will then be copied into the local project.\n ', + examples: [['Build Yarn from master', '$0 set version from sources']], + })), + (0, a.gn)( + [ + C.Command.String('--path', { + description: + 'The path where the repository should be cloned to', + }), + ], + ve.prototype, + 'installPath', + void 0 + ), + (0, a.gn)( + [ + C.Command.String('--repository', { + description: 'The repository that should be cloned', + }), + ], + ve.prototype, + 'repository', + void 0 + ), + (0, a.gn)( + [ + C.Command.String('--branch', { + description: + 'The branch of the repository that should be cloned', + }), + ], + ve.prototype, + 'branch', + void 0 + ), + (0, a.gn)( + [ + C.Command.Array('--plugin', { + description: + 'An array of additional plugins that should be included in the bundle', + }), + ], + ve.prototype, + 'plugins', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--no-minify', { + description: + 'Build a bundle for development (debugging) - non-minified and non-mangled', + }), + ], + ve.prototype, + 'noMinify', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-f,--force', { + description: + 'Always clone the repository instead of trying to fetch the latest commits', + }), + ], + ve.prototype, + 'force', + void 0 + ), + (0, a.gn)( + [C.Command.Path('set', 'version', 'from', 'sources')], + ve.prototype, + 'execute', + null + ); + var Ne = r(78835); + const Fe = require('vm'); + async function Ke(e) { + const t = await me.get( + 'https://raw.githubusercontent.com/yarnpkg/berry/master/plugins.yml', + { configuration: e } + ); + return (0, he.parseSyml)(t.toString()); + } + class Me extends c.BaseCommand { + constructor() { + super(...arguments), (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins); + return ( + await p.Pk.start( + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }, + async (t) => { + const r = await Ke(e); + for (const [e, { experimental: A, ...n }] of Object.entries( + r + )) { + let r = e; + A && (r += ' [experimental]'), + t.reportJson({ name: e, experimental: A, ...n }), + t.reportInfo(null, r); + } + } + ) + ).exitCode(); + } + } + (Me.usage = C.Command.Usage({ + category: 'Plugin-related commands', + description: 'list the available official plugins', + details: + '\n This command prints the plugins available directly from the Yarn repository. Only those plugins can be referenced by name in `yarn plugin import`.\n ', + examples: [['List the official plugins', '$0 plugin list']], + })), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + Me.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [C.Command.Path('plugin', 'list')], + Me.prototype, + 'execute', + null + ); + class Re extends c.BaseCommand { + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (t) => { + const { project: r } = await h.I.find(e, this.context.cwd); + let A, n; + if ( + this.name.match(/^\.{0,2}[\\/]/) || + m.cS.isAbsolute(this.name) + ) { + const o = m.y1.resolve( + this.context.cwd, + m.cS.toPortablePath(this.name) + ); + t.reportInfo( + u.b.UNNAMED, + 'Reading ' + B.pretty(e, o, B.Type.PATH) + ), + (A = m.y1.relative(r.cwd, o)), + (n = await y.xfs.readFilePromise(o)); + } else { + let r; + if (this.name.match(/^https?:/)) { + try { + new Ne.URL(this.name); + } catch (e) { + throw new X.lk( + u.b.INVALID_PLUGIN_REFERENCE, + `Plugin specifier "${this.name}" is neither a plugin name nor a valid url` + ); + } + (A = this.name), (r = this.name); + } else { + const t = d.parseIdent( + this.name.replace( + /^((@yarnpkg\/)?plugin-)?/, + '@yarnpkg/plugin-' + ) + ), + n = d.stringifyIdent(t), + o = await Ke(e); + if (!Object.prototype.hasOwnProperty.call(o, n)) + throw new X.lk( + u.b.PLUGIN_NAME_NOT_FOUND, + `Couldn't find a plugin named "${n}" on the remote registry. Note that only the plugins referenced on our website (https://github.com/yarnpkg/berry/blob/master/plugins.yml) can be referenced by their name; any other plugin will have to be referenced through its public url (for example https://github.com/yarnpkg/berry/raw/master/packages/plugin-typescript/bin/%40yarnpkg/plugin-typescript.js).` + ); + (A = n), (r = o[n].url); + } + t.reportInfo( + u.b.UNNAMED, + 'Downloading ' + B.pretty(e, r, 'green') + ), + (n = await me.get(r, { configuration: e })); + } + await xe(A, n, { project: r, report: t }); + } + ) + ).exitCode(); + } + } + async function xe(e, t, { project: r, report: A }) { + const { configuration: n } = r, + o = {}, + i = { exports: o }; + (0, Fe.runInNewContext)(t.toString(), { module: i, exports: o }); + const a = i.exports.name, + c = `.yarn/plugins/${a}.cjs`, + g = m.y1.resolve(r.cwd, c); + A.reportInfo( + u.b.UNNAMED, + 'Saving the new plugin in ' + B.pretty(n, c, 'magenta') + ), + await y.xfs.mkdirPromise(m.y1.dirname(g), { recursive: !0 }), + await y.xfs.writeFilePromise(g, t); + const l = { path: c, spec: e }; + await s.VK.updateConfiguration(r.cwd, (e) => { + const t = []; + let A = !1; + for (const n of e.plugins || []) { + const e = 'string' != typeof n ? n.path : n, + o = m.y1.resolve(r.cwd, m.cS.toPortablePath(e)), + { name: i } = P.dynamicRequire(m.cS.fromPortablePath(o)); + i !== a ? t.push(n) : (t.push(l), (A = !0)); + } + return A || t.push(l), { ...e, plugins: t }; + }); + } + (Re.usage = C.Command.Usage({ + category: 'Plugin-related commands', + description: 'download a plugin', + details: + "\n This command downloads the specified plugin from its remote location and updates the configuration to reference it in further CLI invocations.\n\n Three types of plugin references are accepted:\n\n - If the plugin is stored within the Yarn repository, it can be referenced by name.\n - Third-party plugins can be referenced directly through their public urls.\n - Local plugins can be referenced by their path on the disk.\n\n Plugins cannot be downloaded from the npm registry, and aren't allowed to have dependencies (they need to be bundled into a single file, possibly thanks to the `@yarnpkg/builder` package).\n ", + examples: [ + [ + 'Download and activate the "@yarnpkg/plugin-exec" plugin', + '$0 plugin import @yarnpkg/plugin-exec', + ], + [ + 'Download and activate the "@yarnpkg/plugin-exec" plugin (shorthand)', + '$0 plugin import exec', + ], + [ + 'Download and activate a community plugin', + '$0 plugin import https://example.org/path/to/plugin.js', + ], + ['Activate a local plugin', '$0 plugin import ./path/to/plugin.js'], + ], + })), + (0, a.gn)([C.Command.String()], Re.prototype, 'name', void 0), + (0, a.gn)( + [C.Command.Path('plugin', 'import')], + Re.prototype, + 'execute', + null + ); + class Le extends c.BaseCommand { + constructor() { + super(...arguments), + (this.repository = 'https://github.com/yarnpkg/berry.git'), + (this.branch = 'master'), + (this.noMinify = !1), + (this.force = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + t = + void 0 !== this.installPath + ? m.y1.resolve( + this.context.cwd, + m.cS.toPortablePath(this.installPath) + ) + : m.y1.resolve( + m.cS.toPortablePath((0, Ee.tmpdir)()), + 'yarnpkg-sources', + Ie.makeHash(this.repository).slice(0, 6) + ); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + const { project: A } = await h.I.find(e, this.context.cwd), + n = d.parseIdent( + this.name.replace( + /^((@yarnpkg\/)?plugin-)?/, + '@yarnpkg/plugin-' + ) + ), + o = d.stringifyIdent(n), + i = await Ke(e); + if (!Object.prototype.hasOwnProperty.call(i, o)) + throw new X.lk( + u.b.PLUGIN_NAME_NOT_FOUND, + `Couldn't find a plugin named "${o}" on the remote registry. Note that only the plugins referenced on our website (https://github.com/yarnpkg/berry/blob/master/plugins.yml) can be built and imported from sources.` + ); + const s = o, + a = s.replace(/@yarnpkg\//, ''); + await ke(this, { configuration: e, report: r, target: t }), + r.reportSeparator(), + r.reportInfo(u.b.UNNAMED, 'Building a fresh ' + a), + r.reportSeparator(), + await Se( + (({ pluginName: e, noMinify: t }, r) => [ + [ + 'yarn', + 'build:' + e, + ...(t ? ['--no-minify'] : []), + '|', + ], + ])({ pluginName: a, noMinify: this.noMinify }), + { configuration: e, context: this.context, target: t } + ), + r.reportSeparator(); + const c = m.y1.resolve(t, `packages/${a}/bundles/${s}.js`), + g = await y.xfs.readFilePromise(c); + await xe(s, g, { project: A, report: r }); + } + ) + ).exitCode(); + } + } + (Le.usage = C.Command.Usage({ + category: 'Plugin-related commands', + description: 'build a plugin from sources', + details: + '\n This command clones the Yarn repository into a temporary folder, builds the specified contrib plugin and updates the configuration to reference it in further CLI invocations.\n\n The plugins can be referenced by their short name if sourced from the official Yarn repository.\n ', + examples: [ + [ + 'Build and activate the "@yarnpkg/plugin-exec" plugin', + '$0 plugin import from sources @yarnpkg/plugin-exec', + ], + [ + 'Build and activate the "@yarnpkg/plugin-exec" plugin (shorthand)', + '$0 plugin import from sources exec', + ], + ], + })), + (0, a.gn)([C.Command.String()], Le.prototype, 'name', void 0), + (0, a.gn)( + [ + C.Command.String('--path', { + description: + 'The path where the repository should be cloned to', + }), + ], + Le.prototype, + 'installPath', + void 0 + ), + (0, a.gn)( + [ + C.Command.String('--repository', { + description: 'The repository that should be cloned', + }), + ], + Le.prototype, + 'repository', + void 0 + ), + (0, a.gn)( + [ + C.Command.String('--branch', { + description: + 'The branch of the repository that should be cloned', + }), + ], + Le.prototype, + 'branch', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--no-minify', { + description: + 'Build a plugin for development (debugging) - non-minified and non-mangled', + }), + ], + Le.prototype, + 'noMinify', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-f,--force', { + description: + 'Always clone the repository instead of trying to fetch the latest commits', + }), + ], + Le.prototype, + 'force', + void 0 + ), + (0, a.gn)( + [C.Command.Path('plugin', 'import', 'from', 'sources')], + Le.prototype, + 'execute', + null + ); + class Pe extends c.BaseCommand { + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await h.I.find(e, this.context.cwd); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + const A = this.name, + n = d.parseIdent(A); + if (!e.plugins.has(A)) + throw new C.UsageError( + d.prettyIdent(e, n) + + " isn't referenced by the current configuration" + ); + const o = `.yarn/plugins/${A}.cjs`, + i = m.y1.resolve(t.cwd, o); + y.xfs.existsSync(i) && + (r.reportInfo( + u.b.UNNAMED, + `Removing ${B.pretty(e, o, B.Type.PATH)}...` + ), + await y.xfs.removePromise(i)), + r.reportInfo(u.b.UNNAMED, 'Updating the configuration...'), + await s.VK.updateConfiguration(t.cwd, (e) => { + if (!Array.isArray(e.plugins)) return e; + const t = e.plugins.filter((e) => e.path !== o); + return e.plugins.length === t.length + ? e + : { ...e, plugins: t }; + }); + } + ) + ).exitCode(); + } + } + (Pe.usage = C.Command.Usage({ + category: 'Plugin-related commands', + description: 'remove a plugin', + details: + '\n This command deletes the specified plugin from the .yarn/plugins folder and removes it from the configuration.\n\n **Note:** The plugins have to be referenced by their name property, which can be obtained using the `yarn plugin runtime` command. Shorthands are not allowed.\n ', + examples: [ + [ + 'Remove a plugin imported from the Yarn repository', + '$0 plugin remove @yarnpkg/plugin-typescript', + ], + [ + 'Remove a plugin imported from a local file', + '$0 plugin remove my-local-plugin', + ], + ], + })), + (0, a.gn)([C.Command.String()], Pe.prototype, 'name', void 0), + (0, a.gn)( + [C.Command.Path('plugin', 'remove')], + Pe.prototype, + 'execute', + null + ); + class Oe extends c.BaseCommand { + constructor() { + super(...arguments), (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins); + return ( + await p.Pk.start( + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }, + async (t) => { + for (const r of e.plugins.keys()) { + const e = this.context.plugins.plugins.has(r); + let A = r; + e && (A += ' [builtin]'), + t.reportJson({ name: r, builtin: e }), + t.reportInfo(null, '' + A); + } + } + ) + ).exitCode(); + } + } + (Oe.usage = C.Command.Usage({ + category: 'Plugin-related commands', + description: 'list the active plugins', + details: + '\n This command prints the currently active plugins. Will be displayed both builtin plugins and external plugins.\n ', + examples: [ + ['List the currently active plugins', '$0 plugin runtime'], + ], + })), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + Oe.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [C.Command.Path('plugin', 'runtime')], + Oe.prototype, + 'execute', + null + ); + class Ue extends c.BaseCommand { + constructor() { + super(...arguments), (this.idents = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ), + A = await g.C.find(e); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + const n = new Set(); + for (const e of this.idents) n.add(d.parseIdent(e).identHash); + await t.resolveEverything({ cache: A, report: new I.$() }); + const o = e.get('bstatePath'), + i = y.xfs.existsSync(o) + ? (0, he.parseSyml)(await y.xfs.readFilePromise(o, 'utf8')) + : {}, + a = new Map(); + for (const e of t.storedPackages.values()) { + if (!Object.prototype.hasOwnProperty.call(i, e.locatorHash)) + continue; + if (0 === n.size || n.has(e.identHash)) continue; + const t = i[e.locatorHash]; + a.set(e.locatorHash, t); + } + if (a.size > 0) { + const r = e.get('bstatePath'), + A = h.I.generateBuildStateFile(a, t.storedPackages); + await y.xfs.mkdirPromise(m.y1.dirname(r), { recursive: !0 }), + await y.xfs.changeFilePromise(r, A, { automaticNewlines: !0 }); + } else await y.xfs.removePromise(o); + return ( + await p.Pk.start( + { + configuration: e, + stdout: this.context.stdout, + includeLogs: !this.context.quiet, + }, + async (e) => { + await t.install({ cache: A, report: e }); + } + ) + ).exitCode(); + } + } + (Ue.usage = C.Command.Usage({ + description: "rebuild the project's native packages", + details: + "\n This command will automatically cause Yarn to forget about previous compilations of the given packages and to run them again.\n\n Note that while Yarn forgets the compilation, the previous artifacts aren't erased from the filesystem and may affect the next builds (in good or bad). To avoid this, you may remove the .yarn/unplugged folder, or any other relevant location where packages might have been stored (Yarn may offer a way to do that automatically in the future).\n\n By default all packages will be rebuilt, but you can filter the list by specifying the names of the packages you want to clear from memory.\n ", + examples: [ + ['Rebuild all packages', '$0 rebuild'], + ['Rebuild fsevents only', '$0 rebuild fsevents'], + ], + })), + (0, a.gn)([C.Command.Rest()], Ue.prototype, 'idents', void 0), + (0, a.gn)([C.Command.Path('rebuild')], Ue.prototype, 'execute', null); + class Te extends c.BaseCommand { + constructor() { + super(...arguments), (this.all = !1), (this.patterns = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ), + A = await g.C.find(e); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState({ restoreResolutions: !1 }); + const o = this.all ? t.workspaces : [r], + i = [n.REGULAR, n.DEVELOPMENT, n.PEER], + a = []; + let l = !1; + const u = []; + for (const e of this.patterns) { + let t = !1; + const r = d.parseIdent(e); + for (const A of o) { + const n = [...A.manifest.peerDependenciesMeta.keys()]; + for (const r of Z()(n, e)) + A.manifest.peerDependenciesMeta.delete(r), (l = !0), (t = !0); + for (const e of i) { + const n = A.manifest.getForScope(e), + o = [...n.values()].map((e) => d.stringifyIdent(e)); + for (const i of Z()(o, d.stringifyIdent(r))) { + const { identHash: r } = d.parseIdent(i), + o = n.get(r); + if (void 0 === o) + throw new Error( + 'Assertion failed: Expected the descriptor to be registered' + ); + A.manifest[e].delete(r), + u.push([A, e, o]), + (l = !0), + (t = !0); + } + } + } + t || a.push(e); + } + const f = a.length > 1 ? 'Patterns' : 'Pattern', + I = a.length > 1 ? "don't" : "doesn't", + E = this.all ? 'any' : 'this'; + if (a.length > 0) + throw new C.UsageError( + `${f} ${B.prettyList( + e, + a, + s.a5.CODE + )} ${I} match any packages referenced by ${E} workspace` + ); + if (l) { + await e.triggerMultipleHooks( + (e) => e.afterWorkspaceDependencyRemoval, + u + ); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (e) => { + await t.install({ cache: A, report: e }); + } + ) + ).exitCode(); + } + return 0; + } + } + (Te.usage = C.Command.Usage({ + description: 'remove dependencies from the project', + details: + '\n This command will remove the packages matching the specified patterns from the current workspace.\n\n This command accepts glob patterns as arguments (if valid Idents and supported by [micromatch](https://github.com/micromatch/micromatch)). Make sure to escape the patterns, to prevent your own shell from trying to expand them.\n ', + examples: [ + [ + 'Remove a dependency from the current project', + '$0 remove lodash', + ], + [ + 'Remove a dependency from all workspaces at once', + '$0 remove lodash --all', + ], + [ + 'Remove all dependencies starting with `eslint-`', + "$0 remove 'eslint-*'", + ], + [ + 'Remove all dependencies with the `@babel` scope', + "$0 remove '@babel/*'", + ], + [ + 'Remove all dependencies matching `react-dom` or `react-helmet`', + "$0 remove 'react-{dom,helmet}'", + ], + ], + })), + (0, a.gn)( + [ + C.Command.Boolean('-A,--all', { + description: + 'Apply the operation to all workspaces from the current project', + }), + ], + Te.prototype, + 'all', + void 0 + ), + (0, a.gn)([C.Command.Rest()], Te.prototype, 'patterns', void 0), + (0, a.gn)([C.Command.Path('remove')], Te.prototype, 'execute', null); + class je extends c.BaseCommand { + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (t) => { + const A = r.manifest.scripts, + n = P.sortMap(A.keys(), (e) => e), + o = { + breakLength: 1 / 0, + colors: e.get('enableColors'), + maxArrayLength: 2, + }, + i = n.reduce((e, t) => Math.max(e, t.length), 0); + for (const [e, r] of A.entries()) + t.reportInfo( + null, + `${e.padEnd(i, ' ')} ${(0, T.inspect)(r, o)}` + ); + } + ) + ).exitCode(); + } + } + (0, a.gn)([C.Command.Path('run')], je.prototype, 'execute', null); + class Ye extends c.BaseCommand { + constructor() { + super(...arguments), + (this.inspect = !1), + (this.inspectBrk = !1), + (this.topLevel = !1), + (this.binariesOnly = !1), + (this.args = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r, locator: A } = await h.I.find( + e, + this.context.cwd + ); + await t.restoreInstallState(); + const n = this.topLevel ? t.topLevelWorkspace.anchoredLocator : A; + if ( + !this.binariesOnly && + (await R.hasPackageScript(n, this.scriptName, { project: t })) + ) + return await R.executePackageScript( + n, + this.scriptName, + this.args, + { + project: t, + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + } + ); + if ( + (await R.getPackageAccessibleBinaries(n, { project: t })).get( + this.scriptName + ) + ) { + const e = []; + return ( + this.inspect && + ('string' == typeof this.inspect + ? e.push('--inspect=' + this.inspect) + : e.push('--inspect')), + this.inspectBrk && + ('string' == typeof this.inspectBrk + ? e.push('--inspect-brk=' + this.inspectBrk) + : e.push('--inspect-brk')), + await R.executePackageAccessibleBinary( + n, + this.scriptName, + this.args, + { + cwd: this.context.cwd, + project: t, + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + nodeArgs: e, + } + ) + ); + } + if ( + !this.topLevel && + !this.binariesOnly && + r && + this.scriptName.includes(':') + ) { + const e = ( + await Promise.all( + t.workspaces.map(async (e) => + e.manifest.scripts.has(this.scriptName) ? e : null + ) + ) + ).filter((e) => null !== e); + if (1 === e.length) + return await R.executeWorkspaceScript( + e[0], + this.scriptName, + this.args, + { + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + } + ); + } + if (this.topLevel) + throw 'node-gyp' === this.scriptName + ? new C.UsageError( + `Couldn't find a script name "${ + this.scriptName + }" in the top-level (used by ${d.prettyLocator( + e, + A + )}). This typically happens because some package depends on "node-gyp" to build itself, but didn't list it in their dependencies. To fix that, please run "yarn add node-gyp" into your top-level workspace. You also can open an issue on the repository of the specified package to suggest them to use an optional peer dependency.` + ) + : new C.UsageError( + `Couldn't find a script name "${ + this.scriptName + }" in the top-level (used by ${d.prettyLocator(e, A)}).` + ); + { + if ('global' === this.scriptName) + throw new C.UsageError( + "The 'yarn global' commands have been removed in 2.x - consider using 'yarn dlx' or a third-party plugin instead" + ); + const e = [this.scriptName].concat(this.args); + for (const [t, r] of c.pluginCommands) + for (const A of r) + if ( + e.length >= A.length && + JSON.stringify(e.slice(0, A.length)) === JSON.stringify(A) + ) + throw new C.UsageError( + `Couldn't find a script named "${this.scriptName}", but a matching command can be found in the ${t} plugin. You can install it with "yarn plugin import ${t}".` + ); + throw new C.UsageError( + `Couldn't find a script named "${this.scriptName}".` + ); + } + } + } + (Ye.usage = C.Command.Usage({ + description: 'run a script defined in the package.json', + details: + "\n This command will run a tool. The exact tool that will be executed will depend on the current state of your workspace:\n\n - If the `scripts` field from your local package.json contains a matching script name, its definition will get executed.\n\n - Otherwise, if one of the local workspace's dependencies exposes a binary with a matching name, this binary will get executed.\n\n - Otherwise, if the specified name contains a colon character and if one of the workspaces in the project contains exactly one script with a matching name, then this script will get executed.\n\n Whatever happens, the cwd of the spawned process will be the workspace that declares the script (which makes it possible to call commands cross-workspaces using the third syntax).\n ", + examples: [ + ['Run the tests from the local workspace', '$0 run test'], + ['Same thing, but without the "run" keyword', '$0 test'], + ['Inspect Webpack while running', '$0 run --inspect-brk webpack'], + ], + })), + (0, a.gn)( + [ + C.Command.String('--inspect', { + tolerateBoolean: !0, + description: + 'Forwarded to the underlying Node process when executing a binary', + }), + ], + Ye.prototype, + 'inspect', + void 0 + ), + (0, a.gn)( + [ + C.Command.String('--inspect-brk', { + tolerateBoolean: !0, + description: + 'Forwarded to the underlying Node process when executing a binary', + }), + ], + Ye.prototype, + 'inspectBrk', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('-T,--top-level', { hidden: !0 })], + Ye.prototype, + 'topLevel', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('-B,--binaries-only', { hidden: !0 })], + Ye.prototype, + 'binariesOnly', + void 0 + ), + (0, a.gn)( + [C.Command.Boolean('--silent', { hidden: !0 })], + Ye.prototype, + 'silent', + void 0 + ), + (0, a.gn)([C.Command.String()], Ye.prototype, 'scriptName', void 0), + (0, a.gn)([C.Command.Proxy()], Ye.prototype, 'args', void 0), + (0, a.gn)([C.Command.Path('run')], Ye.prototype, 'execute', null); + class Ge extends c.BaseCommand { + constructor() { + super(...arguments), (this.save = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ), + A = await g.C.find(e); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + const n = d.parseDescriptor(this.descriptor, !0), + o = d.makeDescriptor(n, this.resolution); + t.storedDescriptors.set(n.descriptorHash, n), + t.storedDescriptors.set(o.descriptorHash, o), + t.resolutionAliases.set(n.descriptorHash, o.descriptorHash); + return ( + await p.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (e) => { + await t.install({ cache: A, report: e }); + } + ) + ).exitCode(); + } + } + (Ge.usage = C.Command.Usage({ + description: 'enforce a package resolution', + details: + '\n This command updates the resolution table so that `descriptor` is resolved by `resolution`.\n\n Note that by default this command only affect the current resolution table - meaning that this "manual override" will disappear if you remove the lockfile, or if the package disappear from the table. If you wish to make the enforced resolution persist whatever happens, add the `-s,--save` flag which will also edit the `resolutions` field from your top-level manifest.\n\n Note that no attempt is made at validating that `resolution` is a valid resolution entry for `descriptor`.\n ', + examples: [ + [ + 'Force all instances of lodash@npm:^1.2.3 to resolve to 1.5.0', + '$0 set resolution lodash@npm:^1.2.3 1.5.0', + ], + ], + })), + (0, a.gn)([C.Command.String()], Ge.prototype, 'descriptor', void 0), + (0, a.gn)([C.Command.String()], Ge.prototype, 'resolution', void 0), + (0, a.gn)( + [ + C.Command.Boolean('-s,--save', { + description: + 'Persist the resolution inside the top-level manifest', + }), + ], + Ge.prototype, + 'save', + void 0 + ), + (0, a.gn)( + [C.Command.Path('set', 'resolution')], + Ge.prototype, + 'execute', + null + ); + class He extends c.BaseCommand { + constructor() { + super(...arguments), + (this.patterns = []), + (this.interactive = null), + (this.exact = !1), + (this.tilde = !1), + (this.caret = !1); + } + async execute() { + var e; + const t = await s.VK.find(this.context.cwd, this.context.plugins), + { project: r, workspace: A } = await h.I.find( + t, + this.context.cwd + ), + o = await g.C.find(t); + if (!A) throw new c.WorkspaceRequiredError(r.cwd, this.context.cwd); + const a = + null !== (e = this.interactive) && void 0 !== e + ? e + : t.get('preferInteractive'), + I = D(this, r), + E = a + ? [i.KEEP, i.REUSE, i.PROJECT, i.LATEST] + : [i.PROJECT, i.LATEST], + y = [], + m = []; + for (const e of this.patterns) { + let t = !1; + const A = d.parseDescriptor(e); + for (const e of r.workspaces) + for (const i of [n.REGULAR, n.DEVELOPMENT]) { + const n = [...e.manifest.getForScope(i).values()].map((e) => + d.stringifyIdent(e) + ); + for (const s of Z()(n, d.stringifyIdent(A))) { + const n = d.parseIdent(s), + a = e.manifest[i].get(n.identHash); + if (void 0 === a) + throw new Error( + 'Assertion failed: Expected the descriptor to be registered' + ); + const c = d.makeDescriptor(n, A.range); + y.push( + Promise.resolve().then(async () => [ + e, + i, + a, + await F(c, { + project: r, + workspace: e, + cache: o, + target: i, + modifier: I, + strategies: E, + }), + ]) + ), + (t = !0); + } + } + t || m.push(e); + } + if (m.length > 1) + throw new C.UsageError( + `Patterns ${B.prettyList( + t, + m, + s.a5.CODE + )} don't match any packages referenced by any workspace` + ); + if (m.length > 0) + throw new C.UsageError( + `Pattern ${B.prettyList( + t, + m, + s.a5.CODE + )} doesn't match any packages referenced by any workspace` + ); + const w = await Promise.all(y), + Q = await l.h.start( + { + configuration: t, + stdout: this.context.stdout, + suggestInstall: !1, + }, + async (e) => { + for (const [, , A, { suggestions: n, rejections: o }] of w) { + const i = n.filter((e) => null !== e.descriptor); + if (0 === i.length) { + const [n] = o; + if (void 0 === n) + throw new Error( + 'Assertion failed: Expected an error to have been set' + ); + const i = this.cli.error(n); + r.configuration.get('enableNetwork') + ? e.reportError( + u.b.CANT_SUGGEST_RESOLUTIONS, + `${d.prettyDescriptor( + t, + A + )} can't be resolved to a satisfying range\n\n${i}` + ) + : e.reportError( + u.b.CANT_SUGGEST_RESOLUTIONS, + `${d.prettyDescriptor( + t, + A + )} can't be resolved to a satisfying range (note: network resolution has been disabled)\n\n${i}` + ); + } else + i.length > 1 && + !a && + e.reportError( + u.b.CANT_SUGGEST_RESOLUTIONS, + d.prettyDescriptor(t, A) + + ' has multiple possible upgrade strategies; use -i to disambiguate manually' + ); + } + } + ); + if (Q.hasErrors()) return Q.exitCode(); + let b = !1; + const v = []; + for (const [e, A, , { suggestions: n }] of w) { + let o; + const i = n.filter((e) => null !== e.descriptor), + s = i[0].descriptor, + a = i.every((e) => d.areDescriptorsEqual(e.descriptor, s)); + 1 === i.length || a + ? (o = s) + : ((b = !0), + ({ answer: o } = await (0, f.prompt)({ + type: 'select', + name: 'answer', + message: `Which range to you want to use in ${d.prettyWorkspace( + t, + e + )} ❯ ${A}?`, + choices: n.map(({ descriptor: e, name: t, reason: r }) => + e + ? { name: t, hint: r, descriptor: e } + : { name: t, hint: r, disabled: !0 } + ), + onCancel: () => process.exit(130), + result(e) { + return this.find(e, 'descriptor'); + }, + stdin: this.context.stdin, + stdout: this.context.stdout, + }))); + const c = e.manifest[A].get(o.identHash); + if (void 0 === c) + throw new Error( + 'Assertion failed: This descriptor should have a matching entry' + ); + if (c.descriptorHash !== o.descriptorHash) + e.manifest[A].set(o.identHash, o), v.push([e, A, c, o]); + else { + const A = t.makeResolver(), + n = { project: r, resolver: A }, + o = A.bindDescriptor(c, e.anchoredLocator, n); + r.forgetResolution(o); + } + } + await t.triggerMultipleHooks( + (e) => e.afterWorkspaceDependencyReplacement, + v + ), + b && this.context.stdout.write('\n'); + return ( + await p.Pk.start( + { configuration: t, stdout: this.context.stdout }, + async (e) => { + await r.install({ cache: o, report: e }); + } + ) + ).exitCode(); + } + } + (He.usage = C.Command.Usage({ + description: 'upgrade dependencies across the project', + details: + "\n This command upgrades the packages matching the list of specified patterns to their latest available version across the whole project (regardless of whether they're part of `dependencies` or `devDependencies` - `peerDependencies` won't be affected). This is a project-wide command: all workspaces will be upgraded in the process.\n\n If `-i,--interactive` is set (or if the `preferInteractive` settings is toggled on) the command will offer various choices, depending on the detected upgrade paths. Some upgrades require this flag in order to resolve ambiguities.\n\n The, `-C,--caret`, `-E,--exact` and `-T,--tilde` options have the same meaning as in the `add` command (they change the modifier used when the range is missing or a tag, and are ignored when the range is explicitly set).\n\n Generally you can see `yarn up` as a counterpart to what was `yarn upgrade --latest` in Yarn 1 (ie it ignores the ranges previously listed in your manifests), but unlike `yarn upgrade` which only upgraded dependencies in the current workspace, `yarn up` will upgrade all workspaces at the same time.\n\n This command accepts glob patterns as arguments (if valid Descriptors and supported by [micromatch](https://github.com/micromatch/micromatch)). Make sure to escape the patterns, to prevent your own shell from trying to expand them.\n\n **Note:** The ranges have to be static, only the package scopes and names can contain glob patterns.\n ", + examples: [ + [ + 'Upgrade all instances of lodash to the latest release', + '$0 up lodash', + ], + [ + 'Upgrade all instances of lodash to the latest release, but ask confirmation for each', + '$0 up lodash -i', + ], + ['Upgrade all instances of lodash to 1.2.3', '$0 up lodash@1.2.3'], + [ + 'Upgrade all instances of packages with the `@babel` scope to the latest release', + "$0 up '@babel/*'", + ], + [ + 'Upgrade all instances of packages containing the word `jest` to the latest release', + "$0 up '*jest*'", + ], + [ + 'Upgrade all instances of packages with the `@babel` scope to 7.0.0', + "$0 up '@babel/*@7.0.0'", + ], + ], + })), + (0, a.gn)([C.Command.Rest()], He.prototype, 'patterns', void 0), + (0, a.gn)( + [ + C.Command.Boolean('-i,--interactive', { + description: + 'Offer various choices, depending on the detected upgrade paths', + }), + ], + He.prototype, + 'interactive', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-E,--exact', { + description: + "Don't use any semver modifier on the resolved range", + }), + ], + He.prototype, + 'exact', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-T,--tilde', { + description: + 'Use the `~` semver modifier on the resolved range', + }), + ], + He.prototype, + 'tilde', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('-C,--caret', { + description: + 'Use the `^` semver modifier on the resolved range', + }), + ], + He.prototype, + 'caret', + void 0 + ), + (0, a.gn)([C.Command.Path('up')], He.prototype, 'execute', null); + class Je extends c.BaseCommand { + constructor() { + super(...arguments), + (this.recursive = !1), + (this.json = !1), + (this.peers = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState(); + const A = d.parseIdent(this.package).identHash, + n = this.recursive + ? (function (e, t, { configuration: r, peers: A }) { + const n = P.sortMap(e.workspaces, (e) => + d.stringifyLocator(e.anchoredLocator) + ), + o = new Set(), + i = new Set(), + s = (r) => { + if (o.has(r.locatorHash)) return i.has(r.locatorHash); + if ((o.add(r.locatorHash), r.identHash === t)) + return i.add(r.locatorHash), !0; + let n = !1; + r.identHash === t && (n = !0); + for (const t of r.dependencies.values()) { + if (!A && r.peerDependencies.has(t.identHash)) + continue; + const o = e.storedResolutions.get(t.descriptorHash); + if (!o) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + const i = e.storedPackages.get(o); + if (!i) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + s(i) && (n = !0); + } + return n && i.add(r.locatorHash), n; + }; + for (const t of n) { + const r = e.storedPackages.get( + t.anchoredLocator.locatorHash + ); + if (!r) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + s(r); + } + const a = new Set(), + c = {}, + g = { children: c }, + l = (t, r, n) => { + if (!i.has(t.locatorHash)) return; + const o = {}, + s = { + value: + null !== n + ? B.tuple(B.Type.DEPENDENT, { + locator: t, + descriptor: n, + }) + : B.tuple(B.Type.LOCATOR, t), + children: o, + }; + if ( + ((r[d.stringifyLocator(t)] = s), + !a.has(t.locatorHash) && + (a.add(t.locatorHash), + null === n || !e.tryWorkspaceByLocator(t))) + ) + for (const r of t.dependencies.values()) { + if (!A && t.peerDependencies.has(r.identHash)) + continue; + const n = e.storedResolutions.get(r.descriptorHash); + if (!n) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + const i = e.storedPackages.get(n); + if (!i) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + l(i, o, r); + } + }; + for (const t of n) { + const r = e.storedPackages.get( + t.anchoredLocator.locatorHash + ); + if (!r) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + l(r, c, null); + } + return g; + })(t, A, { configuration: e, peers: this.peers }) + : (function (e, t, { configuration: r, peers: A }) { + const n = P.sortMap(e.storedPackages.values(), (e) => + d.stringifyLocator(e) + ), + o = {}, + i = { children: o }; + for (const r of n) { + const n = {}, + i = null; + for (const s of r.dependencies.values()) { + if (!A && r.peerDependencies.has(s.identHash)) continue; + const a = e.storedResolutions.get(s.descriptorHash); + if (!a) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + const c = e.storedPackages.get(a); + if (!c) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + if (c.identHash !== t) continue; + if (null === i) { + const e = d.stringifyLocator(r); + o[e] = { value: [r, B.Type.LOCATOR], children: n }; + } + const g = d.stringifyLocator(c); + n[g] = { + value: [ + { descriptor: s, locator: c }, + B.Type.DEPENDENT, + ], + }; + } + } + return i; + })(t, A, { configuration: e, peers: this.peers }); + le.emitTree(n, { + configuration: e, + stdout: this.context.stdout, + json: this.json, + separators: 1, + }); + } + } + (Je.usage = C.Command.Usage({ + description: 'display the reason why a package is needed', + details: + '\n This command prints the exact reasons why a package appears in the dependency tree.\n\n If `-R,--recursive` is set, the listing will go in depth and will list, for each workspaces, what are all the paths that lead to the dependency. Note that the display is somewhat optimized in that it will not print the package listing twice for a single package, so if you see a leaf named "Foo" when looking for "Bar", it means that "Foo" already got printed higher in the tree.\n ', + examples: [ + ['Explain why lodash is used in your project', '$0 why lodash'], + ], + })), + (0, a.gn)([C.Command.String()], Je.prototype, 'package', void 0), + (0, a.gn)( + [ + C.Command.Boolean('-R,--recursive', { + description: + 'List, for each workspace, what are all the paths that lead to the dependency', + }), + ], + Je.prototype, + 'recursive', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + Je.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--peers', { + description: + 'Also print the peer dependencies that match the specified name', + }), + ], + Je.prototype, + 'peers', + void 0 + ), + (0, a.gn)([C.Command.Path('why')], Je.prototype, 'execute', null); + class qe extends c.BaseCommand { + constructor() { + super(...arguments), (this.verbose = !1), (this.json = !1); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await h.I.find(e, this.context.cwd); + return ( + await p.Pk.start( + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }, + async (e) => { + for (const r of t.workspaces) { + const { manifest: A } = r; + let n; + if (this.verbose) { + const e = new Set(), + r = new Set(); + for (const n of E.G.hardDependencies) + for (const [o, i] of A.getForScope(n)) { + const A = t.tryWorkspaceByDescriptor(i); + null === A + ? t.workspacesByIdent.has(o) && r.add(i) + : e.add(A); + } + n = { + workspaceDependencies: Array.from(e).map( + (e) => e.relativeCwd + ), + mismatchedWorkspaceDependencies: Array.from( + r + ).map((e) => d.stringifyDescriptor(e)), + }; + } + e.reportInfo(null, '' + r.relativeCwd), + e.reportJson({ + location: r.relativeCwd, + name: A.name ? d.stringifyIdent(A.name) : null, + ...n, + }); + } + } + ) + ).exitCode(); + } + } + (qe.usage = C.Command.Usage({ + category: 'Workspace-related commands', + description: 'list all available workspaces', + details: + '\n This command will print the list of all workspaces in the project. If both the `-v,--verbose` and `--json` options are set, Yarn will also return the cross-dependencies between each workspaces (useful when you wish to automatically generate Buck / Bazel rules).\n ', + })), + (0, a.gn)( + [ + C.Command.Boolean('-v,--verbose', { + description: + 'Also return the cross-dependencies between workspaces', + }), + ], + qe.prototype, + 'verbose', + void 0 + ), + (0, a.gn)( + [ + C.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + qe.prototype, + 'json', + void 0 + ), + (0, a.gn)( + [C.Command.Path('workspaces', 'list')], + qe.prototype, + 'execute', + null + ); + class ze extends C.Command { + constructor() { + super(...arguments), (this.args = []); + } + async execute() { + const e = await s.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await h.I.find( + e, + this.context.cwd + ); + if (!r) throw new c.WorkspaceRequiredError(t.cwd, this.context.cwd); + const A = t.workspaces, + n = new Map( + A.map((e) => { + const t = d.convertToIdent(e.locator); + return [d.stringifyIdent(t), e]; + }) + ), + o = n.get(this.workspaceName); + if (void 0 === o) { + const e = Array.from(n.keys()).sort(); + throw new C.UsageError( + `Workspace '${ + this.workspaceName + }' not found. Did you mean any of the following:\n - ${e.join( + '\n - ' + )}?` + ); + } + return this.cli.run([this.commandName, ...this.args], { + cwd: o.cwd, + }); + } + } + (ze.usage = C.Command.Usage({ + category: 'Workspace-related commands', + description: 'run a command within the specified workspace', + details: + '\n This command will run a given sub-command on a single workspace.\n ', + examples: [ + [ + 'Add a package to a single workspace', + 'yarn workspace components add -D react', + ], + [ + 'Run build script on a single workspace', + 'yarn workspace components run build', + ], + ], + })), + (0, a.gn)( + [C.Command.String()], + ze.prototype, + 'workspaceName', + void 0 + ), + (0, a.gn)([C.Command.String()], ze.prototype, 'commandName', void 0), + (0, a.gn)([C.Command.Proxy()], ze.prototype, 'args', void 0), + (0, a.gn)( + [C.Command.Path('workspace')], + ze.prototype, + 'execute', + null + ); + const We = { + configuration: { + enableImmutableInstalls: { + description: + 'If true, prevents the install command from modifying the lockfile', + type: s.a2.BOOLEAN, + default: !1, + }, + defaultSemverRangePrefix: { + description: "The default save prefix: '^', '~' or ''", + type: s.a2.STRING, + values: ['^', '~', ''], + default: o.CARET, + }, + }, + commands: [ + L, + j, + q, + Ge, + ve, + we, + qe, + re, + Ae, + ne, + ie, + M, + x, + z, + te, + ae, + ge, + ue, + de, + Ce, + fe, + Le, + Re, + Pe, + Me, + Oe, + Ue, + Te, + je, + Ye, + He, + Je, + ze, + ], + }; + }, + 68023: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => E, fileUtils: () => A }); + var A = {}; + r.r(A), + r.d(A, { + makeArchiveFromLocator: () => p, + makeBufferFromLocator: () => d, + makeLocator: () => h, + makeSpec: () => u, + parseSpec: () => l, + }); + var n = r(54143), + o = r(46009); + const i = /^(?:[a-zA-Z]:[\\/]|\.{0,2}\/)/, + s = /^[^?]*\.(?:tar\.gz|tgz)(?:::.*)?$/; + var a = r(73632), + c = r(72785), + g = r(75448); + function l(e) { + const { params: t, selector: r } = n.parseRange(e), + A = o.cS.toPortablePath(r); + return { + parentLocator: + t && 'string' == typeof t.locator + ? n.parseLocator(t.locator) + : null, + path: A, + }; + } + function u({ parentLocator: e, path: t, folderHash: r, protocol: A }) { + const o = null !== e ? { locator: n.stringifyLocator(e) } : {}, + i = void 0 !== r ? { hash: r } : {}; + return n.makeRange({ + protocol: A, + source: t, + selector: t, + params: { ...i, ...o }, + }); + } + function h( + e, + { parentLocator: t, path: r, folderHash: A, protocol: o } + ) { + return n.makeLocator( + e, + u({ parentLocator: t, path: r, folderHash: A, protocol: o }) + ); + } + async function p( + e, + { protocol: t, fetchOptions: r, inMemory: A = !1 } + ) { + const { + parentLocator: i, + path: s, + } = n.parseFileStyleRange(e.reference, { protocol: t }), + l = o.y1.isAbsolute(s) + ? { + packageFs: new g.M(o.LZ.root), + prefixPath: o.LZ.dot, + localPath: o.LZ.root, + } + : await r.fetcher.fetch(i, r), + u = l.localPath + ? { + packageFs: new g.M(o.LZ.root), + prefixPath: o.y1.relative(o.LZ.root, l.localPath), + } + : l; + l !== u && l.releaseFs && l.releaseFs(); + const h = u.packageFs, + p = o.y1.join(u.prefixPath, s); + return await a.releaseAfterUseAsync( + async () => + await c.makeArchiveFromDirectory(p, { + baseFs: h, + prefixPath: n.getIdentVendorPath(e), + compressionLevel: r.project.configuration.get( + 'compressionLevel' + ), + inMemory: A, + }), + u.releaseFs + ); + } + async function d(e, { protocol: t, fetchOptions: r }) { + return ( + await p(e, { protocol: t, fetchOptions: r, inMemory: !0 }) + ).getBufferAndClose(); + } + var C = r(20624), + f = r(32485), + I = r(46611); + const E = { + fetchers: [ + class { + supports(e, t) { + return ( + !!s.test(e.reference) && !!e.reference.startsWith('file:') + ); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [A, o, i] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + n.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the disk" + ), + loader: () => this.fetchFromDisk(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: A, + releaseFs: o, + prefixPath: n.getIdentVendorPath(e), + checksum: i, + }; + } + async fetchFromDisk(e, t) { + const { + parentLocator: r, + path: A, + } = n.parseFileStyleRange(e.reference, { protocol: 'file:' }), + i = o.y1.isAbsolute(A) + ? { + packageFs: new g.M(o.LZ.root), + prefixPath: o.LZ.dot, + localPath: o.LZ.root, + } + : await t.fetcher.fetch(r, t), + s = i.localPath + ? { + packageFs: new g.M(o.LZ.root), + prefixPath: o.y1.relative(o.LZ.root, i.localPath), + } + : i; + i !== s && i.releaseFs && i.releaseFs(); + const l = s.packageFs, + u = o.y1.join(s.prefixPath, A), + h = await l.readFilePromise(u); + return await a.releaseAfterUseAsync( + async () => + await c.convertToZip(h, { + compressionLevel: t.project.configuration.get( + 'compressionLevel' + ), + prefixPath: n.getIdentVendorPath(e), + stripComponents: 1, + }), + s.releaseFs + ); + } + }, + class { + supports(e, t) { + return !!e.reference.startsWith('file:'); + } + getLocalPath(e, t) { + const { + parentLocator: r, + path: A, + } = n.parseFileStyleRange(e.reference, { protocol: 'file:' }); + if (o.y1.isAbsolute(A)) return A; + const i = t.fetcher.getLocalPath(r, t); + return null === i ? null : o.y1.resolve(i, A); + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [A, o, i] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + n.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the disk" + ), + loader: () => this.fetchFromDisk(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: A, + releaseFs: o, + prefixPath: n.getIdentVendorPath(e), + localPath: this.getLocalPath(e, t), + checksum: i, + }; + } + async fetchFromDisk(e, t) { + return p(e, { protocol: 'file:', fetchOptions: t }); + } + }, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return ( + !!s.test(e.range) && + (!!e.range.startsWith('file:') || !!i.test(e.range)) + ); + } + supportsLocator(e, t) { + return ( + !!s.test(e.reference) && !!e.reference.startsWith('file:') + ); + } + shouldPersistResolution(e, t) { + return !0; + } + bindDescriptor(e, t, r) { + return ( + i.test(e.range) && + (e = n.makeDescriptor(e, 'file:' + e.range)), + n.bindDescriptor(e, { locator: n.stringifyLocator(t) }) + ); + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + let A = e.range; + return ( + A.startsWith('file:') && (A = A.slice('file:'.length)), + [n.makeLocator(e, 'file:' + o.cS.toPortablePath(A))] + ); + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + if (!t.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const r = await t.fetchOptions.fetcher.fetch(e, t.fetchOptions), + A = await a.releaseAfterUseAsync( + async () => + await I.G.find(r.prefixPath, { baseFs: r.packageFs }), + r.releaseFs + ); + return { + ...e, + version: A.version || '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: f.Un.HARD, + dependencies: A.dependencies, + peerDependencies: A.peerDependencies, + dependenciesMeta: A.dependenciesMeta, + peerDependenciesMeta: A.peerDependenciesMeta, + bin: A.bin, + }; + } + }, + class { + supportsDescriptor(e, t) { + return !!e.range.match(i) || !!e.range.startsWith('file:'); + } + supportsLocator(e, t) { + return !!e.reference.startsWith('file:'); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + return ( + i.test(e.range) && + (e = n.makeDescriptor(e, 'file:' + e.range)), + n.bindDescriptor(e, { locator: n.stringifyLocator(t) }) + ); + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + if (!r.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const { path: A, parentLocator: o } = l(e.range); + if (null === o) + throw new Error( + 'Assertion failed: The descriptor should have been bound' + ); + const i = await d( + n.makeLocator( + e, + n.makeRange({ + protocol: 'file:', + source: A, + selector: A, + params: { locator: n.stringifyLocator(o) }, + }) + ), + { protocol: 'file:', fetchOptions: r.fetchOptions } + ); + return [ + h(e, { + parentLocator: o, + path: A, + folderHash: C.makeHash('1', i).slice(0, 6), + protocol: 'file:', + }), + ]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + if (!t.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const r = await t.fetchOptions.fetcher.fetch(e, t.fetchOptions), + A = await a.releaseAfterUseAsync( + async () => + await I.G.find(r.prefixPath, { baseFs: r.packageFs }), + r.releaseFs + ); + return { + ...e, + version: A.version || '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: f.Un.HARD, + dependencies: A.dependencies, + peerDependencies: A.peerDependencies, + dependenciesMeta: A.dependenciesMeta, + peerDependenciesMeta: A.peerDependenciesMeta, + bin: A.bin, + }; + } + }, + ], + }; + }, + 75641: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => F, gitUtils: () => A }); + var A = {}; + r.r(A), + r.d(A, { + TreeishProtocols: () => y, + clone: () => S, + isGitUrl: () => m, + lsRemote: () => b, + normalizeLocator: () => D, + normalizeRepoUrl: () => Q, + resolveUrl: () => v, + splitRepoUrl: () => w, + }); + var n = r(39922), + o = r(54143), + i = r(63088), + s = r(73632), + a = r(72785), + c = r(43896), + g = r(46009), + l = r(79669), + u = r(6220), + h = r(71191), + p = r.n(h), + d = r(53887), + C = r.n(d), + f = r(78835), + I = r.n(f); + function E() { + return { ...process.env, GIT_SSH_COMMAND: 'ssh -o BatchMode=yes' }; + } + const B = [ + /^ssh:/, + /^git(?:\+[^:]+)?:/, + /^(?:git\+)?https?:[^#]+\/[^#]+(?:\.git)(?:#.*)?$/, + /^git@[^#]+\/[^#]+\.git(?:#.*)?$/, + /^(?:github:|https:\/\/github\.com\/)?(?!\.{1,2}\/)([a-zA-Z._0-9-]+)\/(?!\.{1,2}(?:#|$))([a-zA-Z._0-9-]+?)(?:\.git)?(?:#.*)?$/, + /^https:\/\/github\.com\/(?!\.{1,2}\/)([a-zA-Z0-9._-]+)\/(?!\.{1,2}(?:#|$))([a-zA-Z0-9._-]+?)\/tarball\/(.+)?$/, + ]; + var y; + function m(e) { + return !!e && B.some((t) => !!e.match(t)); + } + function w(e) { + const t = (e = Q(e)).indexOf('#'); + if (-1 === t) + return { + repo: e, + treeish: { protocol: y.Head, request: 'master' }, + extra: {}, + }; + const r = e.slice(0, t), + A = e.slice(t + 1); + if (A.match(/^[a-z]+=/)) { + const e = p().parse(A); + for (const [t, r] of Object.entries(e)) + if ('string' != typeof r) + throw new Error( + `Assertion failed: The ${t} parameter must be a literal string` + ); + const t = Object.values(y).find((t) => + Object.prototype.hasOwnProperty.call(e, t) + ); + let n, o; + void 0 !== t + ? ((n = t), (o = e[t])) + : ((n = y.Head), (o = 'master')); + for (const t of Object.values(y)) delete e[t]; + return { repo: r, treeish: { protocol: n, request: o }, extra: e }; + } + { + const e = A.indexOf(':'); + let t, n; + return ( + -1 === e + ? ((t = null), (n = A)) + : ((t = A.slice(0, e)), (n = A.slice(e + 1))), + { repo: r, treeish: { protocol: t, request: n }, extra: {} } + ); + } + } + function Q(e, { git: t = !1 } = {}) { + var r; + if ( + ((e = (e = (e = e.replace(/^git\+https:/, 'https:')).replace( + /^(?:github:|https:\/\/github\.com\/)?(?!\.{1,2}\/)([a-zA-Z0-9._-]+)\/(?!\.{1,2}(?:#|$))([a-zA-Z0-9._-]+?)(?:\.git)?(#.*)?$/, + 'https://github.com/$1/$2.git$3' + )).replace( + /^https:\/\/github\.com\/(?!\.{1,2}\/)([a-zA-Z0-9._-]+)\/(?!\.{1,2}(?:#|$))([a-zA-Z0-9._-]+?)\/tarball\/(.+)?$/, + 'https://github.com/$1/$2.git#$3' + )), + t) + ) { + let t; + e = e.replace(/^git\+([^:]+):/, '$1:'); + try { + t = I().parse(e); + } catch (e) { + t = null; + } + t && + 'ssh:' === t.protocol && + (null === (r = t.path) || void 0 === r + ? void 0 + : r.startsWith('/:')) && + (e = e.replace(/^ssh:\/\//, '')); + } + return e; + } + function D(e) { + return o.makeLocator(e, Q(e.reference)); + } + async function b(e, t) { + const r = Q(e, { git: !0 }); + if (!l.getNetworkSettings(r, { configuration: t }).enableNetwork) + throw new Error( + `Request to '${r}' has been blocked because of your configuration settings` + ); + let A; + try { + A = await u.execvp('git', ['ls-remote', '--refs', r], { + cwd: t.startingCwd, + env: E(), + strict: !0, + }); + } catch (t) { + throw ((t.message = `Listing the refs for ${e} failed`), t); + } + const n = new Map(), + o = /^([a-f0-9]{40})\t(refs\/[^\n]+)/gm; + let i; + for (; null !== (i = o.exec(A.stdout)); ) n.set(i[2], i[1]); + return n; + } + async function v(e, t) { + const { + repo: r, + treeish: { protocol: A, request: n }, + extra: o, + } = w(e), + i = await b(r, t), + s = (e, t) => { + switch (e) { + case y.Commit: + if (!t.match(/^[a-f0-9]{40}$/)) + throw new Error('Invalid commit hash'); + return p().stringify({ ...o, commit: t }); + case y.Head: { + const e = i.get('refs/heads/' + t); + if (void 0 === e) throw new Error(`Unknown head ("${t}")`); + return p().stringify({ ...o, commit: e }); + } + case y.Tag: { + const e = i.get('refs/tags/' + t); + if (void 0 === e) throw new Error(`Unknown tag ("${t}")`); + return p().stringify({ ...o, commit: e }); + } + case y.Semver: { + if (!C().validRange(t)) + throw new Error(`Invalid range ("${t}")`); + const e = new Map( + [...i.entries()] + .filter(([e]) => e.startsWith('refs/tags/')) + .map(([e, t]) => [C().parse(e.slice(10)), t]) + .filter((e) => null !== e[0]) + ), + r = C().maxSatisfying([...e.keys()], t); + if (null === r) throw new Error(`No matching range ("${t}")`); + return p().stringify({ ...o, commit: e.get(r) }); + } + case null: { + let e; + if (null !== (e = a(y.Commit, t))) return e; + if (null !== (e = a(y.Tag, t))) return e; + if (null !== (e = a(y.Head, t))) return e; + throw t.match(/^[a-f0-9]+$/) + ? new Error( + `Couldn't resolve "${t}" as either a commit, a tag, or a head - if a commit, use the 40-characters commit hash` + ) + : new Error( + `Couldn't resolve "${t}" as either a commit, a tag, or a head` + ); + } + default: + throw new Error(`Invalid Git resolution protocol ("${e}")`); + } + }, + a = (e, t) => { + try { + return s(e, t); + } catch (e) { + return null; + } + }; + return `${r}#${s(A, n)}`; + } + async function S(e, t) { + return await t.getLimit('cloneConcurrency')(async () => { + const { + repo: r, + treeish: { protocol: A, request: n }, + } = w(e); + if ('commit' !== A) + throw new Error('Invalid treeish protocol when cloning'); + const o = Q(r, { git: !0 }); + if ( + !1 === l.getNetworkSettings(o, { configuration: t }).enableNetwork + ) + throw new Error( + `Request to '${o}' has been blocked because of your configuration settings` + ); + const i = await c.xfs.mktempPromise(), + s = { cwd: i, env: E(), strict: !0 }; + try { + await u.execvp( + 'git', + [ + 'clone', + '-c core.autocrlf=false', + o, + g.cS.fromPortablePath(i), + ], + s + ), + await u.execvp('git', ['checkout', '' + n], s); + } catch (e) { + throw ((e.message = 'Repository clone failed: ' + e.message), e); + } + return i; + }); + } + !(function (e) { + (e.Commit = 'commit'), + (e.Head = 'head'), + (e.Tag = 'tag'), + (e.Semver = 'semver'); + })(y || (y = {})); + var k = r(32485), + N = r(46611); + const F = { + configuration: { + cloneConcurrency: { + description: 'Maximal number of concurrent clones', + type: n.a2.NUMBER, + default: 2, + }, + }, + fetchers: [ + class { + supports(e, t) { + return m(e.reference); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + A = D(e), + n = new Map(t.checksums); + n.set(A.locatorHash, r); + const i = { ...t, checksums: n }, + s = await this.downloadHosted(A, i); + if (null !== s) return s; + const [a, c, g] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + o.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the remote repository" + ), + loader: () => this.cloneFromRemote(A, i), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: a, + releaseFs: c, + prefixPath: o.getIdentVendorPath(e), + checksum: g, + }; + } + async downloadHosted(e, t) { + return t.project.configuration.reduceHook( + (e) => e.fetchHostedRepository, + null, + e, + t + ); + } + async cloneFromRemote(e, t) { + const r = await S(e.reference, t.project.configuration), + A = w(e.reference), + n = g.y1.join(r, 'package.tgz'); + await i.prepareExternalProject(r, n, { + configuration: t.project.configuration, + report: t.report, + workspace: A.extra.workspace, + }); + const l = await c.xfs.readFilePromise(n); + return await s.releaseAfterUseAsync( + async () => + await a.convertToZip(l, { + compressionLevel: t.project.configuration.get( + 'compressionLevel' + ), + prefixPath: o.getIdentVendorPath(e), + stripComponents: 1, + }) + ); + } + }, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return m(e.range); + } + supportsLocator(e, t) { + return m(e.reference); + } + shouldPersistResolution(e, t) { + return !0; + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + const A = await v(e.range, r.project.configuration); + return [o.makeLocator(e, A)]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + if (!t.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const r = await t.fetchOptions.fetcher.fetch(e, t.fetchOptions), + A = await s.releaseAfterUseAsync( + async () => + await N.G.find(r.prefixPath, { baseFs: r.packageFs }), + r.releaseFs + ); + return { + ...e, + version: A.version || '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: k.Un.HARD, + dependencies: A.dependencies, + peerDependencies: A.peerDependencies, + dependenciesMeta: A.dependenciesMeta, + peerDependenciesMeta: A.peerDependenciesMeta, + bin: A.bin, + }; + } + }, + ], + }; + }, + 68126: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => d }); + var A = r(54143), + n = r(79669), + o = r(72785), + i = r(63088), + s = r(43896), + a = r(75448), + c = r(46009), + g = r(75641), + l = r(71191), + u = r.n(l); + const h = [ + /^https?:\/\/(?:([^/]+?)@)?github.com\/([^/#]+)\/([^/#]+)\/tarball\/([^/#]+)(?:#(.*))?$/, + /^https?:\/\/(?:([^/]+?)@)?github.com\/([^/#]+)\/([^/#]+?)(?:\.git)?(?:#(.*))?$/, + ]; + class p { + supports(e, t) { + return !(!(r = e.reference) || !h.some((e) => !!r.match(e))); + var r; + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [n, o, i] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + A.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from GitHub" + ), + loader: () => this.fetchFromNetwork(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: n, + releaseFs: o, + prefixPath: A.getIdentVendorPath(e), + checksum: i, + }; + } + async fetchFromNetwork(e, t) { + const r = await n.get(this.getLocatorUrl(e, t), { + configuration: t.project.configuration, + }); + return await s.xfs.mktempPromise(async (n) => { + const l = new a.M(n); + await o.extractArchiveTo(r, l, { stripComponents: 1 }); + const u = g.gitUtils.splitRepoUrl(e.reference), + h = c.y1.join(n, 'package.tgz'); + await i.prepareExternalProject(n, h, { + configuration: t.project.configuration, + report: t.report, + workspace: u.extra.workspace, + }); + const p = await s.xfs.readFilePromise(h); + return await o.convertToZip(p, { + compressionLevel: t.project.configuration.get( + 'compressionLevel' + ), + prefixPath: A.getIdentVendorPath(e), + stripComponents: 1, + }); + }); + } + getLocatorUrl(e, t) { + const { + auth: r, + username: A, + reponame: n, + treeish: o, + } = (function (e) { + let t; + for (const r of h) if (((t = e.match(r)), t)) break; + if (!t) + throw new Error( + `Input cannot be parsed as a valid GitHub URL ('${e}').` + ); + let [, r, A, n, o = 'master'] = t; + const { commit: i } = u().parse(o); + return ( + (o = i || o.replace(/[^:]*:/, '')), + { auth: r, username: A, reponame: n, treeish: o } + ); + })(e.reference); + return `https://${ + r ? r + '@' : '' + }github.com/${A}/${n}/archive/${o}.tar.gz`; + } + } + const d = { + hooks: { + async fetchHostedRepository(e, t, r) { + if (null !== e) return e; + const A = new p(); + if (!A.supports(t, r)) return null; + try { + return await A.fetch(t, r); + } catch (e) { + return null; + } + }, + }, + }; + }, + 99148: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => l }); + var A = r(54143), + n = r(79669), + o = r(72785); + const i = /^[^?]*\.(?:tar\.gz|tgz)(?:\?.*)?$/, + s = /^https?:/; + var a = r(46611), + c = r(32485), + g = r(73632); + const l = { + fetchers: [ + class { + supports(e, t) { + return !!i.test(e.reference) && !!s.test(e.reference); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [n, o, i] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + A.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the remote server" + ), + loader: () => this.fetchFromNetwork(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: n, + releaseFs: o, + prefixPath: A.getIdentVendorPath(e), + checksum: i, + }; + } + async fetchFromNetwork(e, t) { + const r = await n.get(e.reference, { + configuration: t.project.configuration, + }); + return await o.convertToZip(r, { + compressionLevel: t.project.configuration.get( + 'compressionLevel' + ), + prefixPath: A.getIdentVendorPath(e), + stripComponents: 1, + }); + } + }, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return !!i.test(e.range) && !!s.test(e.range); + } + supportsLocator(e, t) { + return !!i.test(e.reference) && !!s.test(e.reference); + } + shouldPersistResolution(e, t) { + return !0; + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + return [A.convertDescriptorToLocator(e)]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + if (!t.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const r = await t.fetchOptions.fetcher.fetch(e, t.fetchOptions), + A = await g.releaseAfterUseAsync( + async () => + await a.G.find(r.prefixPath, { baseFs: r.packageFs }), + r.releaseFs + ); + return { + ...e, + version: A.version || '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: c.Un.HARD, + dependencies: A.dependencies, + peerDependencies: A.peerDependencies, + dependenciesMeta: A.dependenciesMeta, + peerDependenciesMeta: A.peerDependenciesMeta, + bin: A.bin, + }; + } + }, + ], + }; + }, + 64314: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => I }); + var A = r(39922), + n = r(36370), + o = r(25413), + i = r(46611), + s = r(85824), + a = r(6220), + c = r(63088), + g = r(54143), + l = r(43896), + u = r(46009), + h = r(40822), + p = r(80305), + d = r.n(p), + C = r(31669); + class f extends o.BaseCommand { + constructor() { + super(...arguments), + (this.usev2 = !1), + (this.assumeFreshProject = !1), + (this.yes = !1), + (this.private = !1), + (this.workspace = !1), + (this.install = !1); + } + async execute() { + if (l.xfs.existsSync(u.y1.join(this.context.cwd, i.G.fileName))) + throw new h.UsageError( + 'A package.json already exists in the specified directory' + ); + const e = await A.VK.find(this.context.cwd, this.context.plugins), + t = this.install + ? !0 === this.install + ? 'latest' + : this.install + : null; + return null !== t + ? await this.executeProxy(e, t) + : await this.executeRegular(e); + } + async executeProxy(e, t) { + if (null !== e.get('yarnPath')) + throw new h.UsageError( + `Cannot use the --install flag when the current directory already uses yarnPath (from ${e.sources.get( + 'yarnPath' + )})` + ); + if (null !== e.projectCwd) + throw new h.UsageError( + 'Cannot use the --install flag when the current directory is already part of a project' + ); + l.xfs.existsSync(this.context.cwd) || + (await l.xfs.mkdirPromise(this.context.cwd, { recursive: !0 })); + const r = u.y1.join(this.context.cwd, e.get('lockfileFilename')); + l.xfs.existsSync(r) || (await l.xfs.writeFilePromise(r, '')); + const A = await this.cli.run(['set', 'version', t]); + if (0 !== A) return A; + this.context.stdout.write('\n'); + const n = ['--assume-fresh-project']; + return ( + this.private && n.push('-p'), + this.workspace && n.push('-w'), + this.yes && n.push('-y'), + await l.xfs.mktempPromise(async (e) => { + const { code: t } = await a.pipevp('yarn', ['init', ...n], { + cwd: this.context.cwd, + stdin: this.context.stdin, + stdout: this.context.stdout, + stderr: this.context.stderr, + env: await c.makeScriptEnv({ binFolder: e }), + }); + return t; + }) + ); + } + async executeRegular(e) { + let t = null; + if (!this.assumeFreshProject) + try { + t = await s.I.find(e, this.context.cwd); + } catch (e) { + t = null; + } + l.xfs.existsSync(this.context.cwd) || + (await l.xfs.mkdirPromise(this.context.cwd, { recursive: !0 })); + const r = new i.G(), + A = Object.fromEntries(e.get('initFields').entries()); + r.load(A), + (r.name = g.makeIdent( + e.get('initScope'), + u.y1.basename(this.context.cwd) + )), + (r.version = e.get('initVersion')), + (r.private = this.private || this.workspace), + (r.license = e.get('initLicense')), + this.workspace && + (await l.xfs.mkdirPromise( + u.y1.join(this.context.cwd, 'packages'), + { recursive: !0 } + ), + (r.workspaceDefinitions = [{ pattern: 'packages/*' }])); + const n = {}; + r.exportTo(n), + (C.inspect.styles.name = 'cyan'), + this.context.stdout.write( + (0, C.inspect)(n, { depth: 1 / 0, colors: !0, compact: !1 }) + + '\n' + ); + const o = u.y1.join(this.context.cwd, i.G.fileName); + await l.xfs.changeFilePromise(o, JSON.stringify(n, null, 2) + '\n'); + const c = u.y1.join(this.context.cwd, 'README.md'); + if ( + (l.xfs.existsSync(c) || + (await l.xfs.writeFilePromise( + c, + `# ${g.stringifyIdent(r.name)}\n` + )), + !t) + ) { + const t = u.y1.join(this.context.cwd, u.QS.lockfile); + await l.xfs.writeFilePromise(t, ''); + const r = ['/.yarn/** linguist-vendored'] + .map((e) => e + '\n') + .join(''), + A = u.y1.join(this.context.cwd, '.gitattributes'); + l.xfs.existsSync(A) || (await l.xfs.writeFilePromise(A, r)); + const n = [ + '/.yarn/*', + '!/.yarn/releases', + '!/.yarn/plugins', + '!/.yarn/sdks', + '', + "# Swap the comments on the following lines if you don't wish to use zero-installs", + '# Documentation here: https://yarnpkg.com/features/zero-installs', + '!/.yarn/cache', + '#/.pnp.*', + ] + .map((e) => e + '\n') + .join(''), + o = u.y1.join(this.context.cwd, '.gitignore'); + l.xfs.existsSync(o) || (await l.xfs.writeFilePromise(o, n)); + const i = { + '*': { endOfLine: 'lf', insertFinalNewline: !0 }, + '*.{js,json,.yml}': { + charset: 'utf-8', + indentStyle: 'space', + indentSize: 2, + }, + }; + d()(i, e.get('initEditorConfig')); + let s = 'root = true\n'; + for (const [e, t] of Object.entries(i)) { + s += `\n[${e}]\n`; + for (const [e, r] of Object.entries(t)) { + s += `${e.replace( + /[A-Z]/g, + (e) => '_' + e.toLowerCase() + )} = ${r}\n`; + } + } + const c = u.y1.join(this.context.cwd, '.editorconfig'); + l.xfs.existsSync(c) || (await l.xfs.writeFilePromise(c, s)), + await a.execvp('git', ['init'], { cwd: this.context.cwd }); + } + } + } + (f.usage = h.Command.Usage({ + description: 'create a new package', + details: + '\n This command will setup a new package in your local directory.\n\n If the `-p,--private` or `-w,--workspace` options are set, the package will be private by default.\n\n If the `-w,--workspace` option is set, the package will be configured to accept a set of workspaces in the `packages/` directory.\n\n If the `-i,--install` option is given a value, Yarn will first download it using `yarn set version` and only then forward the init call to the newly downloaded bundle. Without arguments, the downloaded bundle will be `latest`.\n\n The initial settings of the manifest can be changed by using the `initScope` and `initFields` configuration values. Additionally, Yarn will generate an EditorConfig file whose rules can be altered via `initEditorConfig`, and will initialize a Git repository in the current directory.\n ', + examples: [ + ['Create a new package in the local directory', 'yarn init'], + [ + 'Create a new private package in the local directory', + 'yarn init -p', + ], + [ + 'Create a new package and store the Yarn release inside', + 'yarn init -i latest', + ], + [ + 'Create a new private package and defines it as a workspace root', + 'yarn init -w', + ], + ], + })), + (0, n.gn)( + [h.Command.Boolean('-2', { hidden: !0 })], + f.prototype, + 'usev2', + void 0 + ), + (0, n.gn)( + [h.Command.Boolean('--assume-fresh-project', { hidden: !0 })], + f.prototype, + 'assumeFreshProject', + void 0 + ), + (0, n.gn)( + [h.Command.Boolean('-y,--yes', { hidden: !0 })], + f.prototype, + 'yes', + void 0 + ), + (0, n.gn)( + [ + h.Command.Boolean('-p,--private', { + description: 'Initialize a private package', + }), + ], + f.prototype, + 'private', + void 0 + ), + (0, n.gn)( + [ + h.Command.Boolean('-w,--workspace', { + description: + 'Initialize a private workspace root with a `packages/` directory', + }), + ], + f.prototype, + 'workspace', + void 0 + ), + (0, n.gn)( + [ + h.Command.String('-i,--install', { + tolerateBoolean: !0, + description: + 'Initialize a package with a specific bundle that will be locked in the project', + }), + ], + f.prototype, + 'install', + void 0 + ), + (0, n.gn)([h.Command.Path('init')], f.prototype, 'execute', null); + const I = { + configuration: { + initLicense: { + description: + 'License used when creating packages via the init command', + type: A.a2.STRING, + default: null, + }, + initScope: { + description: + 'Scope used when creating packages via the init command', + type: A.a2.STRING, + default: null, + }, + initVersion: { + description: + 'Version used when creating packages via the init command', + type: A.a2.STRING, + default: null, + }, + initFields: { + description: + 'Additional fields to set when creating packages via the init command', + type: A.a2.MAP, + valueDefinition: { description: '', type: A.a2.ANY }, + }, + initEditorConfig: { + description: + 'Extra rules to define in the generator editorconfig', + type: A.a2.MAP, + valueDefinition: { description: '', type: A.a2.ANY }, + }, + }, + commands: [f], + }; + }, + 92994: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => g }); + var A = r(54143), + n = r(46009), + o = r(75448), + i = r(10489); + var s = r(46611), + a = r(32485), + c = r(73632); + const g = { + fetchers: [ + class { + supports(e, t) { + return !!e.reference.startsWith('link:'); + } + getLocalPath(e, t) { + const { + parentLocator: r, + path: o, + } = A.parseFileStyleRange(e.reference, { protocol: 'link:' }); + if (n.y1.isAbsolute(o)) return o; + const i = t.fetcher.getLocalPath(r, t); + return null === i ? null : n.y1.resolve(i, o); + } + async fetch(e, t) { + const { + parentLocator: r, + path: s, + } = A.parseFileStyleRange(e.reference, { protocol: 'link:' }), + a = n.y1.isAbsolute(s) + ? { + packageFs: new o.M(n.LZ.root), + prefixPath: n.LZ.dot, + localPath: n.LZ.root, + } + : await t.fetcher.fetch(r, t), + c = a.localPath + ? { + packageFs: new o.M(n.LZ.root), + prefixPath: n.y1.relative(n.LZ.root, a.localPath), + } + : a; + a !== c && a.releaseFs && a.releaseFs(); + const g = c.packageFs, + l = n.y1.join(c.prefixPath, s); + return a.localPath + ? { + packageFs: new o.M(l, { baseFs: g }), + releaseFs: c.releaseFs, + prefixPath: n.LZ.dot, + discardFromLookup: !0, + localPath: l, + } + : { + packageFs: new i.n(l, { baseFs: g }), + releaseFs: c.releaseFs, + prefixPath: n.LZ.dot, + discardFromLookup: !0, + }; + } + }, + class { + supports(e, t) { + return !!e.reference.startsWith('portal:'); + } + getLocalPath(e, t) { + const { + parentLocator: r, + path: o, + } = A.parseFileStyleRange(e.reference, { protocol: 'portal:' }); + if (n.y1.isAbsolute(o)) return o; + const i = t.fetcher.getLocalPath(r, t); + return null === i ? null : n.y1.resolve(i, o); + } + async fetch(e, t) { + const { parentLocator: r, path: s } = A.parseFileStyleRange( + e.reference, + { + protocol: 'portal:', + } + ), + a = n.y1.isAbsolute(s) + ? { + packageFs: new o.M(n.LZ.root), + prefixPath: n.LZ.dot, + localPath: n.LZ.root, + } + : await t.fetcher.fetch(r, t), + c = a.localPath + ? { + packageFs: new o.M(n.LZ.root), + prefixPath: n.y1.relative(n.LZ.root, a.localPath), + } + : a; + a !== c && a.releaseFs && a.releaseFs(); + const g = c.packageFs, + l = n.y1.join(c.prefixPath, s); + return a.localPath + ? { + packageFs: new o.M(l, { baseFs: g }), + releaseFs: c.releaseFs, + prefixPath: n.LZ.dot, + localPath: l, + } + : { + packageFs: new i.n(l, { baseFs: g }), + releaseFs: c.releaseFs, + prefixPath: n.LZ.dot, + }; + } + }, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return !!e.range.startsWith('link:'); + } + supportsLocator(e, t) { + return !!e.reference.startsWith('link:'); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + return A.bindDescriptor(e, { locator: A.stringifyLocator(t) }); + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + const o = e.range.slice('link:'.length); + return [A.makeLocator(e, 'link:' + n.cS.toPortablePath(o))]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + return { + ...e, + version: '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: a.Un.SOFT, + dependencies: new Map(), + peerDependencies: new Map(), + dependenciesMeta: new Map(), + peerDependenciesMeta: new Map(), + bin: new Map(), + }; + } + }, + class { + supportsDescriptor(e, t) { + return !!e.range.startsWith('portal:'); + } + supportsLocator(e, t) { + return !!e.reference.startsWith('portal:'); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + return A.bindDescriptor(e, { locator: A.stringifyLocator(t) }); + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + const o = e.range.slice('portal:'.length); + return [A.makeLocator(e, 'portal:' + n.cS.toPortablePath(o))]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + if (!t.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const r = await t.fetchOptions.fetcher.fetch(e, t.fetchOptions), + A = await c.releaseAfterUseAsync( + async () => + await s.G.find(r.prefixPath, { baseFs: r.packageFs }), + r.releaseFs + ); + return { + ...e, + version: A.version || '0.0.0', + languageName: t.project.configuration.get( + 'defaultLanguageName' + ), + linkType: a.Un.SOFT, + dependencies: new Map([ + ...A.dependencies, + ...A.devDependencies, + ]), + peerDependencies: A.peerDependencies, + dependenciesMeta: A.dependenciesMeta, + peerDependenciesMeta: A.peerDependenciesMeta, + bin: A.bin, + }; + } + }, + ], + }; + }, + 8375: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => ne, getPnpPath: () => Ae }); + var A, + n = r(39922), + o = r(46009), + i = r(54143); + !(function (e) { + (e[(e.YES = 0)] = 'YES'), + (e[(e.NO = 1)] = 'NO'), + (e[(e.DEPENDS = 2)] = 'DEPENDS'); + })(A || (A = {})); + const s = (e, t) => `${e}@${t}`, + a = (e, t) => { + const r = t.indexOf('#'), + A = r >= 0 ? t.substring(r + 1) : t; + return s(e, A); + }; + var c; + !(function (e) { + (e[(e.NONE = -1)] = 'NONE'), + (e[(e.PERF = 0)] = 'PERF'), + (e[(e.CHECK = 1)] = 'CHECK'), + (e[(e.REASONS = 2)] = 'REASONS'), + (e[(e.INTENSIVE_CHECK = 9)] = 'INTENSIVE_CHECK'); + })(c || (c = {})); + const g = (e, t) => { + if (t.decoupled) return t; + const { + name: r, + references: A, + ident: n, + locator: o, + dependencies: i, + originalDependencies: s, + hoistedDependencies: a, + peerNames: c, + reasons: g, + isHoistBorder: l, + } = t, + u = { + name: r, + references: new Set(A), + ident: n, + locator: o, + dependencies: new Map(i), + originalDependencies: new Map(s), + hoistedDependencies: new Map(a), + peerNames: new Set(c), + reasons: new Map(g), + decoupled: !0, + isHoistBorder: l, + }, + h = u.dependencies.get(r); + return ( + h && h.ident == u.ident && u.dependencies.set(r, u), + e.dependencies.set(u.name, u), + u + ); + }, + l = (e) => { + const t = new Set(), + r = (A, n = new Set()) => { + if (!n.has(A)) { + n.add(A); + for (const o of A.peerNames) + if (!e.peerNames.has(o)) { + const A = e.dependencies.get(o); + A && !t.has(A) && r(A, n); + } + t.add(A); + } + }; + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || r(t); + return t; + }, + u = (e, t, r, A, n = new Set()) => { + const o = t[t.length - 1]; + if (n.has(o)) return; + n.add(o); + const i = ((e, t) => { + const r = new Map([[e.name, [e.ident]]]); + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || r.set(t.name, [t.ident]); + const A = Array.from(t.keys()); + A.sort((e, r) => { + const A = t.get(e), + n = t.get(r); + return n.peerDependents.size !== A.peerDependents.size + ? n.peerDependents.size - A.peerDependents.size + : n.dependents.size - A.dependents.size; + }); + for (const t of A) { + const A = t.substring(0, t.indexOf('@', 1)), + n = t.substring(A.length + 1); + if (!e.peerNames.has(A)) { + let e = r.get(A); + e || ((e = []), r.set(A, e)), e.indexOf(n) < 0 && e.push(n); + } + } + return r; + })(o, E(o)), + s = new Map(Array.from(i.entries()).map(([e, t]) => [e, t[0]])), + a = + o === e + ? new Map() + : ((e) => { + const t = new Map(), + r = new Set(), + A = (n) => { + if (!r.has(n)) { + r.add(n); + for (const r of n.hoistedDependencies.values()) + e.dependencies.has(r.name) || t.set(r.name, r); + for (const e of n.dependencies.values()) + n.peerNames.has(e.name) || A(e); + } + }; + return A(e), t; + })(o); + let c; + do { + p(e, t, r, a, s, i, A), (c = !1); + for (const [e, t] of i) + t.length > 1 && + !o.dependencies.has(e) && + (s.delete(e), t.shift(), s.set(e, t[0]), (c = !0)); + } while (c); + for (const n of o.dependencies.values()) + o.peerNames.has(n.name) || + r.has(n.locator) || + (r.add(n.locator), u(e, [...t, n], r, A), r.delete(n.locator)); + }, + h = (e, t, r, n, o, i, { outputReason: s }) => { + let a, + c = null, + g = new Set(); + s && + (a = + '' + + Array.from(e) + .map((e) => B(e)) + .join('→')); + const l = t[t.length - 1], + u = r.ident === l.ident, + h = o.get(r.name); + let p = h === r.ident && !u; + if ( + (s && + !p && + h && + !u && + (c = `- filled by: ${B(i.get(r.name)[0])} at ${a}`), + p) + ) { + let e = !1; + const A = n.get(r.name); + if ( + ((e = !A || A.ident === r.ident), + s && !e && (c = `- filled by: ${B(A.locator)} at ${a}`), + e) + ) + for (let A = 1; A < t.length - 1; A++) { + const n = t[A], + o = n.dependencies.get(r.name); + if (o && o.ident !== r.ident) { + (e = !1), + s && + (c = `- filled by: ${B(o.locator)} at ${B(n.locator)}`); + break; + } + } + p = e; + } + if (p) { + let e = !0; + const A = new Set(r.peerNames); + for (let r = t.length - 1; r >= 1; r--) { + const n = t[r]; + for (const o of A) { + if (n.peerNames.has(o) && n.originalDependencies.has(o)) + continue; + const i = n.dependencies.get(o); + i && + (r === t.length - 1 + ? g.add(i) + : ((g = null), + (e = !1), + s && + (c = `- peer dependency ${B( + i.locator + )} from parent ${B( + n.locator + )} was not hoisted to ${a}`))), + A.delete(o); + } + if (!e) break; + } + p = e; + } + return null !== g && g.size > 0 + ? { isHoistable: A.DEPENDS, dependsOn: g, reason: c } + : { isHoistable: p ? A.YES : A.NO, reason: c }; + }, + p = (e, t, r, n, o, i, s) => { + const a = t[t.length - 1], + u = new Set(), + p = (t, C, I, E) => { + if (u.has(I)) return; + const m = [...C, I.locator], + w = new Map(), + Q = new Map(); + for (const e of l(I)) { + let g = null; + if ( + (g || + (g = h(r, [a, ...t, I], e, n, o, i, { + outputReason: s.debugLevel >= c.REASONS, + })), + Q.set(e, g), + g.isHoistable === A.DEPENDS) + ) + for (const t of g.dependsOn) { + const r = w.get(t.name) || new Set(); + r.add(e.name), w.set(t.name, r); + } + } + const D = new Set(), + b = (e, t, r) => { + if (!D.has(e)) { + D.add(e), + e.ident !== I.ident && + Q.set(e, { isHoistable: A.NO, reason: r }); + for (const A of w.get(e.name) || []) + b(I.dependencies.get(A), t, r); + } + }; + let v; + s.debugLevel >= c.REASONS && + (v = + '' + + Array.from(r) + .map((e) => B(e)) + .join('→')); + for (const [e, t] of Q) + t.isHoistable === A.NO && + b( + e, + t, + `- peer dependency ${B(e.locator)} from parent ${B( + I.locator + )} was not hoisted to ${v}` + ); + for (const e of Q.keys()) + if (!D.has(e)) { + I.dependencies.delete(e.name), + I.hoistedDependencies.set(e.name, e), + I.reasons.delete(e.name); + const t = a.dependencies.get(e.name); + if (t) for (const r of e.references) t.references.add(r); + else + a.ident !== e.ident && + (a.dependencies.set(e.name, e), E.add(e)); + } + if (s.check) { + const r = d(e); + if (r) + throw new Error( + `${r}, after hoisting dependencies of ${[a, ...t, I] + .map((e) => B(e.locator)) + .join('→')}:\n${y(e)}` + ); + } + const S = l(I); + for (const e of S) + if (D.has(e) && m.indexOf(e.locator) < 0) { + const r = Q.get(e); + if ( + (r.isHoistable !== A.YES && + I.reasons.set(e.name, r.reason), + !e.isHoistBorder) + ) { + u.add(I); + const r = g(I, e); + p([...t, I], [...C, I.locator], r, f), u.delete(I); + } + } + }; + let C, + f = new Set(l(a)); + do { + (C = f), (f = new Set()); + for (const e of C) { + if (e.locator === a.locator || e.isHoistBorder) continue; + const t = g(a, e); + p([], Array.from(r), t, f); + } + } while (f.size > 0); + }, + d = (e) => { + const t = [], + r = new Set(), + A = new Set(), + n = (e, o) => { + if (r.has(e)) return; + if ((r.add(e), A.has(e))) return; + const i = new Map(o); + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || i.set(t.name, t); + for (const r of e.originalDependencies.values()) { + const n = i.get(r.name), + s = () => + '' + + Array.from(A) + .concat([e]) + .map((e) => B(e.locator)) + .join('→'); + if (e.peerNames.has(r.name)) { + const e = o.get(r.name); + (e === n && e && e.ident === r.ident) || + t.push( + `${s()} - broken peer promise: expected ${ + r.ident + } but found ${e ? e.ident : e}` + ); + } else + n + ? n.ident !== r.ident && + t.push( + `${s()} - broken require promise for ${ + r.name + }: expected ${r.ident}, but found: ${n.ident}` + ) + : t.push( + `${s()} - broken require promise: no required dependency ${ + r.locator + } found` + ); + } + A.add(e); + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || n(t, i); + A.delete(e); + }; + return n(e, e.dependencies), t.join('\n'); + }, + C = (e, t) => { + const { identName: r, name: A, reference: n, peerNames: o } = e, + i = { + name: A, + references: new Set([n]), + locator: s(r, n), + ident: a(r, n), + dependencies: new Map(), + originalDependencies: new Map(), + hoistedDependencies: new Map(), + peerNames: new Set(o), + reasons: new Map(), + decoupled: !0, + isHoistBorder: !0, + }, + c = new Map([[e, i]]), + g = (e, r) => { + let A = c.get(e); + const n = !!A; + if (!A) { + const { + name: n, + identName: o, + reference: i, + peerNames: g, + } = e, + l = t.hoistingLimits.get(r.locator); + (A = { + name: n, + references: new Set([i]), + locator: s(o, i), + ident: a(o, i), + dependencies: new Map(), + originalDependencies: new Map(), + hoistedDependencies: new Map(), + peerNames: new Set(g), + reasons: new Map(), + decoupled: !0, + isHoistBorder: !!l && l.has(n), + }), + c.set(e, A); + } + if ( + (r.dependencies.set(e.name, A), + r.originalDependencies.set(e.name, A), + n) + ) { + const e = new Set(), + t = (r) => { + if (!e.has(r)) { + e.add(r), (r.decoupled = !1); + for (const e of r.dependencies.values()) + r.peerNames.has(e.name) || t(e); + } + }; + t(A); + } else for (const t of e.dependencies) g(t, A); + }; + for (const t of e.dependencies) g(t, i); + return i; + }, + f = (e) => e.substring(0, e.indexOf('@', 1)), + I = (e) => { + const t = { + name: e.name, + identName: f(e.locator), + references: new Set(e.references), + dependencies: new Set(), + }, + r = new Set([e]), + A = (e, t, n) => { + const o = r.has(e); + let i; + if (t === e) i = n; + else { + const { name: t, references: r, locator: A } = e; + i = { + name: t, + identName: f(A), + references: r, + dependencies: new Set(), + }; + } + if ((n.dependencies.add(i), !o)) { + r.add(e); + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || A(t, e, i); + r.delete(e); + } + }; + for (const r of e.dependencies.values()) A(r, e, t); + return t; + }, + E = (e) => { + const t = new Map(), + r = new Set([e]), + A = (e) => { + const r = ((e) => `${e.name}@${e.ident}`)(e); + let A = t.get(r); + return ( + A || + ((A = { dependents: new Set(), peerDependents: new Set() }), + t.set(r, A)), + A + ); + }, + n = (e, t) => { + const o = !!r.has(t); + if ((A(t).dependents.add(e.ident), !o)) { + r.add(t); + for (const e of t.dependencies.values()) + if (t.peerNames.has(e.name)) { + A(e).peerDependents.add(t.ident); + } else n(t, e); + } + }; + for (const t of e.dependencies.values()) + e.peerNames.has(t.name) || n(e, t); + return t; + }, + B = (e) => { + const t = e.indexOf('@', 1), + r = e.substring(0, t), + A = e.substring(t + 1); + if ('workspace:.' === A) return '.'; + if (A) { + const e = (A.indexOf('#') > 0 ? A.split('#')[1] : A).replace( + 'npm:', + '' + ); + return A.startsWith('virtual') ? `v:${r}@${e}` : `${r}@${e}`; + } + return '' + r; + }, + y = (e) => { + let t = 0; + const r = (e, A, n = '') => { + if (t > 5e4 || A.has(e)) return ''; + t++; + const o = Array.from(e.dependencies.values()); + let i = ''; + A.add(e); + for (let t = 0; t < o.length; t++) { + const s = o[t]; + if (!e.peerNames.has(s.name)) { + const a = e.reasons.get(s.name), + c = f(s.locator); + (i += `${n}${t < o.length - 1 ? '├─' : '└─'}${ + (A.has(s) ? '>' : '') + + (c !== s.name ? `a:${s.name}:` : '') + + B(s.locator) + + (a ? ' ' + a : '') + }\n`), + (i += r(s, A, `${n}${t < o.length - 1 ? '│ ' : ' '}`)); + } + } + return A.delete(e), i; + }; + return ( + r(e, new Set()) + + (t > 5e4 + ? '\nTree is too large, part of the tree has been dunped\n' + : '') + ); + }; + var m, w; + !(function (e) { + (e.HARD = 'HARD'), (e.SOFT = 'SOFT'); + })(m || (m = {})), + (function (e) { + (e.WORKSPACES = 'workspaces'), + (e.DEPENDENCIES = 'dependencies'), + (e.NONE = 'none'); + })(w || (w = {})); + const Q = (e, t) => { + const { packageTree: r, hoistingLimits: A } = b(e, t), + n = ((e, t = {}) => { + const r = + t.debugLevel || + Number(process.env.NM_DEBUG_LEVEL || c.NONE), + A = { + check: t.check || r >= c.INTENSIVE_CHECK, + debugLevel: r, + hoistingLimits: t.hoistingLimits || new Map(), + }; + A.debugLevel >= c.PERF && console.time('hoist'); + const n = C(e, A); + if ( + (u(n, [n], new Set([n.locator]), A), + A.debugLevel >= c.PERF && console.timeEnd('hoist'), + A.debugLevel >= c.CHECK) + ) { + const e = d(n); + if (e) + throw new Error(`${e}, after hoisting finished:\n${y(n)}`); + } + return A.debugLevel >= c.REASONS && console.log(y(n)), I(n); + })(r, { hoistingLimits: A }); + return v(e, n, t); + }, + D = (e) => `${e.name}@${e.reference}`; + const b = (e, t) => { + const r = e.getDependencyTreeRoots(), + A = new Map(), + n = new Map(), + s = e.getPackageInformation(e.topLevel); + if (null === s) + throw new Error( + 'Assertion failed: Expected the top-level package to have been registered' + ); + const a = e.findPackageLocator(s.packageLocation); + if (null === a) + throw new Error( + 'Assertion failed: Expected the top-level package to have a physical locator' + ); + const c = o.cS.toPortablePath(s.packageLocation), + g = D(a); + if (t.project) { + const e = { children: new Map() }, + r = t.project.cwd.split(o.y1.sep); + for (const [A, n] of t.project.workspacesByCwd) { + const t = A.split(o.y1.sep).slice(r.length); + let s = e; + for (const e of t) { + let t = s.children.get(e); + t || ((t = { children: new Map() }), s.children.set(e, t)), + (s = t); + } + s.workspaceLocator = { + name: i.stringifyIdent(n.anchoredLocator), + reference: n.anchoredLocator.reference, + }; + } + const A = (e, t) => { + if (e.workspaceLocator) { + const r = D(t); + let A = n.get(r); + A || ((A = new Set()), n.set(r, A)), A.add(e.workspaceLocator); + } + for (const r of e.children.values()) + A(r, e.workspaceLocator || t); + }; + for (const t of e.children.values()) A(t, e.workspaceLocator); + } else + for (const e of r) + if (e.name !== a.name || e.reference !== a.reference) { + let t = n.get(g); + t || ((t = new Set()), n.set(g, t)), t.add(e); + } + const l = { + name: a.name, + identName: a.name, + reference: a.reference, + peerNames: s.packagePeers, + dependencies: new Set(), + }, + u = new Map(), + h = (r, s, g, p, d, C, f) => { + var I, E; + const B = ((e, t) => `${D(t)}:${e}`)(r, g); + let y = u.get(B); + const m = !!y; + if ( + (m || + g.name !== a.name || + g.reference !== a.reference || + ((y = l), u.set(B, l)), + y || + ((y = { + name: r, + identName: g.name, + reference: g.reference, + dependencies: new Set(), + peerNames: s.packagePeers, + }), + u.set(B, y)), + f) + ) { + const e = D({ name: p.identName, reference: p.reference }), + t = A.get(e) || new Set(); + A.set(e, t), t.add(y.name); + } + const Q = new Map(s.packageDependencies); + if (t.project) { + const e = t.project.workspacesByCwd.get( + o.cS.toPortablePath(s.packageLocation.slice(0, -1)) + ); + if (e) { + const t = new Set([ + ...Array.from(e.manifest.peerDependencies.values(), (e) => + i.stringifyIdent(e) + ), + ...Array.from(e.manifest.peerDependenciesMeta.keys()), + ]); + for (const e of t) + Q.has(e) || + (Q.set(e, d.get(e) || null), y.peerNames.add(e)); + } + } + const b = D(g), + v = n.get(b); + if (v) for (const e of v) Q.set(e.name + '$wsroot$', e.reference); + p.dependencies.add(y); + const S = + t.pnpifyFs || + !(function (e) { + let t = i.parseDescriptor(e); + return ( + i.isVirtualDescriptor(t) && + (t = i.devirtualizeDescriptor(t)), + t.range.startsWith('portal:') + ); + })(B); + if (!m && S) + for (const [r, A] of Q) + if (null !== A) { + const n = e.getLocator(r, A), + i = e.getLocator(r.replace('$wsroot$', ''), A), + s = e.getPackageInformation(i); + if (null === s) + throw new Error( + 'Assertion failed: Expected the package to have been registered' + ); + const a = + null === (I = t.hoistingLimitsByCwd) || void 0 === I + ? void 0 + : I.get(C), + g = + o.y1.relative( + c, + o.cS.toPortablePath(s.packageLocation) + ) || o.LZ.dot, + l = + null === (E = t.hoistingLimitsByCwd) || void 0 === E + ? void 0 + : E.get(g), + u = + a === w.DEPENDENCIES || + l === w.DEPENDENCIES || + l === w.WORKSPACES; + h(r, s, n, y, Q, g, u); + } + }; + return ( + h(a.name, s, a, l, s.packageDependencies, o.LZ.dot, !1), + { packageTree: l, hoistingLimits: A } + ); + }; + const v = (e, t, r) => { + const A = new Map(), + n = (t, A) => { + const { linkType: n, target: i } = (function (e, t, r) { + const A = t.getLocator( + e.name.replace('$wsroot$', ''), + e.reference + ), + n = t.getPackageInformation(A); + if (null === n) + throw new Error( + 'Assertion failed: Expected the package to be registered' + ); + let i, s; + if (r.pnpifyFs) + (s = o.cS.toPortablePath(n.packageLocation)), (i = m.SOFT); + else { + const r = + t.resolveVirtual && + e.reference && + e.reference.startsWith('virtual:') + ? t.resolveVirtual(n.packageLocation) + : n.packageLocation; + (s = o.cS.toPortablePath(r || n.packageLocation)), + (i = n.linkType); + } + return { linkType: i, target: s }; + })(t, e, r); + return { locator: D(t), target: i, linkType: n, aliases: A }; + }, + s = (e) => { + const [t, r] = e.split('/'); + return r + ? { scope: (0, o.Zu)(t), name: (0, o.Zu)(r) } + : { scope: null, name: (0, o.Zu)(t) }; + }, + a = new Set(), + c = (e, t) => { + if (!a.has(e)) { + a.add(e); + for (const r of e.dependencies) { + if ( + r === e || + (e.identName.endsWith('$wsroot$') && + r.identName === e.identName.replace('$wsroot$', '')) + ) + continue; + const a = Array.from(r.references).sort(), + g = { name: r.identName, reference: a[0] }, + { name: l, scope: u } = s(r.name), + h = u ? [u, l] : [l], + p = o.y1.join(t, 'node_modules'), + d = o.y1.join(p, ...h), + C = n(g, a.slice(1)); + if (!r.name.endsWith('$wsroot$')) { + const e = A.get(d); + if (e) { + if (e.dirList) + throw new Error( + `Assertion failed: ${d} cannot merge dir node with leaf node` + ); + { + const t = i.parseLocator(e.locator), + r = i.parseLocator(C.locator); + if (e.linkType !== C.linkType) + throw new Error( + `Assertion failed: ${d} cannot merge nodes with different link types` + ); + if (t.identHash !== r.identHash) + throw new Error( + `Assertion failed: ${d} cannot merge nodes with different idents ${i.stringifyLocator( + t + )} and ${i.stringifyLocator(r)}` + ); + C.aliases = [ + ...C.aliases, + ...e.aliases, + i.parseLocator(e.locator).reference, + ]; + } + } + A.set(d, C); + const t = d.split('/'), + r = t.indexOf('node_modules'); + let n = t.length - 1; + for (; r >= 0 && n > r; ) { + const e = o.cS.toPortablePath( + t.slice(0, n).join(o.y1.sep) + ), + r = (0, o.Zu)(t[n]), + i = A.get(e); + if (i) { + if (i.dirList) { + if (i.dirList.has(r)) break; + i.dirList.add(r); + } + } else A.set(e, { dirList: new Set([r]) }); + n--; + } + } + c(r, C.linkType === m.SOFT ? C.target : d); + } + } + }, + g = n({ name: t.name, reference: Array.from(t.references)[0] }, []), + l = g.target; + return A.set(l, g), c(t, l), A; + }; + var S = r(92659), + k = r(32485), + N = r(73632), + F = r(46611), + K = r(35691), + M = r(43896), + R = r(17674), + x = r(53660), + L = r(65281), + P = r(11640), + O = r(83228), + U = r(58069), + T = r.n(U), + j = r(40822), + Y = r(35747), + G = r.n(Y); + const H = 'node_modules'; + class J { + constructor(e) { + (this.opts = e), + (this.localStore = new Map()), + (this.customData = { store: new Map() }); + } + getCustomDataKey() { + return JSON.stringify({ name: 'NodeModulesInstaller', version: 1 }); + } + attachCustomData(e) { + this.customData = e; + } + async installPackage(e, t) { + var r; + const A = o.y1.resolve(t.packageFs.getRealPath(), t.prefixPath); + let n = this.customData.store.get(e.locatorHash); + if ( + (void 0 === n && + ((n = await (async function (e, t) { + var r; + const A = + null !== + (r = await F.G.tryFind(t.prefixPath, { + baseFs: t.packageFs, + })) && void 0 !== r + ? r + : new F.G(), + n = new Set(['preinstall', 'install', 'postinstall']); + for (const e of A.scripts.keys()) + n.has(e) || A.scripts.delete(e); + return { + manifest: { + bin: A.bin, + os: A.os, + cpu: A.cpu, + scripts: A.scripts, + }, + misc: { + extractHint: O.jsInstallUtils.getExtractHint(t), + hasBindingGyp: O.jsInstallUtils.hasBindingGyp(t), + }, + }; + })(0, t)), + e.linkType === k.Un.HARD && + this.customData.store.set(e.locatorHash, n)), + !O.jsInstallUtils.checkAndReportManifestCompatibility( + e, + n, + 'link', + { + configuration: this.opts.project.configuration, + report: this.opts.report, + } + )) + ) + return { packageLocation: null, buildDirective: null }; + const s = new Map(), + a = new Set(); + if ( + (s.has(i.stringifyIdent(e)) || + s.set(i.stringifyIdent(e), e.reference), + i.isVirtualLocator(e)) + ) + for (const t of e.peerDependencies.values()) + s.set(i.stringifyIdent(t), null), a.add(i.stringifyIdent(t)); + const c = { + packageLocation: o.cS.fromPortablePath(A) + '/', + packageDependencies: s, + packagePeers: a, + linkType: e.linkType, + discardFromLookup: + null !== (r = t.discardFromLookup) && void 0 !== r && r, + }; + return ( + this.localStore.set(e.locatorHash, { + pkg: e, + customPackageData: n, + dependencyMeta: this.opts.project.getDependencyMeta( + e, + e.version + ), + pnpNode: c, + }), + { packageLocation: A, buildDirective: null } + ); + } + async attachInternalDependencies(e, t) { + const r = this.localStore.get(e.locatorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected information object to have been registered' + ); + for (const [e, A] of t) { + const t = i.areIdentsEqual(e, A) + ? A.reference + : [i.requirableIdent(A), A.reference]; + r.pnpNode.packageDependencies.set(i.requirableIdent(e), t); + } + } + async attachExternalDependents(e, t) { + throw new Error( + "External dependencies haven't been implemented for the node-modules linker" + ); + } + async finalizeInstall() { + if ( + 'node-modules' !== + this.opts.project.configuration.get('nodeLinker') + ) + return; + const e = new R.p({ + baseFs: new x.A({ + libzip: await (0, L.getLibzipPromise)(), + maxOpenFiles: 80, + readOnlyArchives: !0, + }), + }); + let t = await q(this.opts.project); + if (null === t) { + const e = this.opts.project.configuration.get('bstatePath'); + (await M.xfs.existsPromise(e)) && (await M.xfs.unlinkPromise(e)), + (t = { + locatorMap: new Map(), + binSymlinks: new Map(), + locationTree: new Map(), + }); + } + const r = new Map( + this.opts.project.workspaces.map((e) => { + var t, r; + let A = this.opts.project.configuration.get( + 'nmHoistingLimits' + ); + try { + A = N.validateEnum( + w, + null !== + (r = + null === (t = e.manifest.installConfig) || + void 0 === t + ? void 0 + : t.hoistingLimits) && void 0 !== r + ? r + : A + ); + } catch (t) { + const r = i.prettyWorkspace( + this.opts.project.configuration, + e + ); + this.opts.report.reportWarning( + S.b.INVALID_MANIFEST, + `${r}: Invalid 'installConfig.hoistingLimits' value. Expected one of ${Object.values( + w + ).join(', ')}, using default: "${A}"` + ); + } + return [e.relativeCwd, A]; + }) + ), + A = ((e) => { + const t = new Map(); + for (const [r, A] of e.entries()) + if (!A.dirList) { + let e = t.get(A.locator); + e || + ((e = { + target: A.target, + linkType: A.linkType, + locations: [], + aliases: A.aliases, + }), + t.set(A.locator, e)), + e.locations.push(r); + } + for (const e of t.values()) + e.locations = e.locations.sort((e, t) => { + const r = e.split(o.y1.delimiter).length, + A = t.split(o.y1.delimiter).length; + return r !== A ? A - r : t.localeCompare(e); + }); + return t; + })( + Q( + { + VERSIONS: { std: 1 }, + topLevel: { name: null, reference: null }, + getLocator: (e, t) => + Array.isArray(t) + ? { name: t[0], reference: t[1] } + : { name: e, reference: t }, + getDependencyTreeRoots: () => + this.opts.project.workspaces.map((e) => { + const t = e.anchoredLocator; + return { + name: i.stringifyIdent(e.locator), + reference: t.reference, + }; + }), + getPackageInformation: (e) => { + const t = + null === e.reference + ? this.opts.project.topLevelWorkspace + .anchoredLocator + : i.makeLocator(i.parseIdent(e.name), e.reference), + r = this.localStore.get(t.locatorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the package reference to have been registered' + ); + return r.pnpNode; + }, + findPackageLocator: (e) => { + const t = this.opts.project.tryWorkspaceByCwd( + o.cS.toPortablePath(e) + ); + if (null !== t) { + const e = t.anchoredLocator; + return { + name: i.stringifyIdent(e), + reference: e.reference, + }; + } + throw new Error('Assertion failed: Unimplemented'); + }, + resolveToUnqualified: () => { + throw new Error('Assertion failed: Unimplemented'); + }, + resolveUnqualified: () => { + throw new Error('Assertion failed: Unimplemented'); + }, + resolveRequest: () => { + throw new Error('Assertion failed: Unimplemented'); + }, + resolveVirtual: (e) => + o.cS.fromPortablePath( + R.p.resolveVirtual(o.cS.toPortablePath(e)) + ), + }, + { + pnpifyFs: !1, + hoistingLimitsByCwd: r, + project: this.opts.project, + } + ) + ); + await (async function ( + e, + t, + { baseFs: r, project: A, report: n, loadManifest: s } + ) { + const a = o.y1.join(A.cwd, H), + { locationTree: c, binSymlinks: g } = (function (e, t) { + const r = new Map([...e]), + A = new Map([...t]); + for (const [t, r] of e) { + const e = o.y1.join(t, H); + if (!M.xfs.existsSync(e)) { + r.children.delete(H); + for (const t of A.keys()) + null !== o.y1.contains(e, t) && A.delete(t); + } + } + return { locationTree: r, binSymlinks: A }; + })(e.locationTree, e.binSymlinks), + l = V(t, { skipPrefix: A.cwd }), + u = [], + h = async ({ srcDir: e, dstDir: t, linkType: A }) => { + const n = (async () => { + try { + A === k.Un.SOFT + ? (await M.xfs.mkdirPromise(o.y1.dirname(t), { + recursive: !0, + }), + await X(o.y1.resolve(e), t)) + : await _(t, e, { baseFs: r }); + } catch (r) { + throw ( + ((r.message = `While persisting ${e} -> ${t} ${r.message}`), + r) + ); + } finally { + I.tick(); + } + })().then(() => u.splice(u.indexOf(n), 1)); + u.push(n), u.length > 4 && (await Promise.race(u)); + }, + p = async (e, t, r) => { + const A = (async () => { + const A = async (e, t, r) => { + try { + (r && r.innerLoop) || + (await M.xfs.mkdirPromise(t, { recursive: !0 })); + const n = await M.xfs.readdirPromise(e, { + withFileTypes: !0, + }); + for (const i of n) { + if (!((r && r.innerLoop) || '.bin' !== i.name)) + continue; + const n = o.y1.join(e, i.name), + s = o.y1.join(t, i.name); + i.isDirectory() + ? (i.name !== H || (r && r.innerLoop)) && + (await M.xfs.mkdirPromise(s, { recursive: !0 }), + await A(n, s, { innerLoop: !0 })) + : await M.xfs.copyFilePromise( + n, + s, + G().constants.COPYFILE_FICLONE + ); + } + } catch (A) { + throw ( + ((r && r.innerLoop) || + (A.message = `While cloning ${e} -> ${t} ${A.message}`), + A) + ); + } finally { + (r && r.innerLoop) || I.tick(); + } + }; + await A(e, t, r); + })().then(() => u.splice(u.indexOf(A), 1)); + u.push(A), u.length > 4 && (await Promise.race(u)); + }, + d = async (e, t, r) => { + if (r) + for (const [A, n] of t.children) { + const t = r.children.get(A); + await d(o.y1.join(e, A), n, t); + } + else + t.children.has(H) && + (await z(o.y1.join(e, H), { contentsOnly: !1 })), + await z(e, { contentsOnly: e === a }); + }; + for (const [e, t] of c) { + const r = l.get(e); + for (const [A, n] of t.children) { + if ('.' === A) continue; + const t = r ? r.children.get(A) : r; + await d(o.y1.join(e, A), n, t); + } + } + const C = async (e, t, r) => { + if (r) { + $(t.locator, r.locator) || + (await z(e, { contentsOnly: t.linkType === k.Un.HARD })); + for (const [A, n] of t.children) { + const t = r.children.get(A); + await C(o.y1.join(e, A), n, t); + } + } else + t.children.has(H) && + (await z(o.y1.join(e, H), { contentsOnly: !0 })), + await z(e, { contentsOnly: t.linkType === k.Un.HARD }); + }; + for (const [e, t] of l) { + const r = c.get(e); + for (const [A, n] of t.children) { + if ('.' === A) continue; + const t = r ? r.children.get(A) : r; + await C(o.y1.join(e, A), n, t); + } + } + const f = []; + for (const [r, { locations: n }] of e.locatorMap.entries()) + for (const e of n) { + const { locationRoot: n, segments: i } = W(e, { + skipPrefix: A.cwd, + }); + let s = l.get(n), + a = n; + if (s) { + for (const e of i) + if (((a = o.y1.join(a, e)), (s = s.children.get(e)), !s)) + break; + if (s && !$(s.locator, r)) { + const e = t.get(s.locator), + r = e.target, + A = a, + n = e.linkType; + r !== A && f.push({ srcDir: r, dstDir: A, linkType: n }); + } + } + } + for (const [e, { locations: r }] of t.entries()) + for (const n of r) { + const { locationRoot: r, segments: i } = W(n, { + skipPrefix: A.cwd, + }); + let s = c.get(r), + a = l.get(r), + g = r; + const u = t.get(e), + h = u.target, + p = n; + if (h === p) continue; + const d = u.linkType; + for (const e of i) a = a.children.get(e); + if (s) { + for (const e of i) + if ( + ((g = o.y1.join(g, e)), (s = s.children.get(e)), !s) + ) { + f.push({ srcDir: h, dstDir: p, linkType: d }); + break; + } + } else f.push({ srcDir: h, dstDir: p, linkType: d }); + } + const I = K.yG.progressViaCounter(f.length), + E = n.reportProgress(I); + try { + const e = new Map(); + for (const t of f) + (t.linkType !== k.Un.SOFT && e.has(t.srcDir)) || + (e.set(t.srcDir, t.dstDir), await h({ ...t })); + await Promise.all(u), (u.length = 0); + for (const t of f) { + const r = e.get(t.srcDir); + t.linkType !== k.Un.SOFT && + t.dstDir !== r && + (await p(r, t.dstDir)); + } + await Promise.all(u), + await M.xfs.mkdirPromise(a, { recursive: !0 }); + const r = await (async function (e, t, r, { loadManifest: A }) { + const n = new Map(); + for (const [t, { locations: r }] of e) { + const e = Z(t) ? null : await A(t, r[0]), + i = new Map(); + if (e) + for (const [t, A] of e.bin) { + const e = o.y1.join(r[0], A); + '' !== A && M.xfs.existsSync(e) && i.set(t, A); + } + n.set(t, i); + } + const i = new Map(), + s = (e, t, A) => { + const a = new Map(), + c = o.y1.contains(r, e); + if (A.locator && null !== c) { + const t = n.get(A.locator); + for (const [r, A] of t) { + const t = o.y1.join(e, o.cS.toPortablePath(A)); + a.set((0, o.Zu)(r), t); + } + for (const [t, r] of A.children) { + const A = o.y1.join(e, t), + n = s(A, A, r); + n.size > 0 && + i.set( + e, + new Map([...(i.get(e) || new Map()), ...n]) + ); + } + } else + for (const [r, n] of A.children) { + const A = s(o.y1.join(e, r), t, n); + for (const [e, t] of A) a.set(e, t); + } + return a; + }; + for (const [e, r] of t) { + const t = s(e, e, r); + t.size > 0 && + i.set(e, new Map([...(i.get(e) || new Map()), ...t])); + } + return i; + })(t, l, A.cwd, { loadManifest: s }); + await (async function (e, t) { + for (const r of e.keys()) + if (!t.has(r)) { + const e = o.y1.join(r, H, '.bin'); + await M.xfs.removePromise(e); + } + for (const [r, A] of t) { + const t = o.y1.join(r, H, '.bin'), + n = e.get(r) || new Map(); + await M.xfs.mkdirPromise(t, { recursive: !0 }); + for (const e of n.keys()) + A.has(e) || + (await M.xfs.removePromise(o.y1.join(t, e)), + 'win32' === process.platform && + (await M.xfs.removePromise( + o.y1.join(t, (0, o.Zu)(e + '.cmd')) + ))); + for (const [e, r] of A) { + const A = n.get(e), + i = o.y1.join(t, e); + A !== r && + ('win32' === process.platform + ? await T()( + o.cS.fromPortablePath(r), + o.cS.fromPortablePath(i), + { createPwshFile: !1 } + ) + : (await M.xfs.removePromise(i), + await X(r, i), + await M.xfs.chmodPromise(r, 493))); + } + } + })(g, r), + await (async function (e, t, r) { + let A = ''; + (A += + '# Warning: This file is automatically generated. Removing it is fine, but will\n'), + (A += + '# cause your node_modules installation to become invalidated.\n'), + (A += '\n'), + (A += '__metadata:\n'), + (A += ' version: 1\n'); + const n = Array.from(t.keys()).sort(), + s = i.stringifyLocator( + e.topLevelWorkspace.anchoredLocator + ); + for (const i of n) { + const n = t.get(i); + (A += '\n'), + (A += JSON.stringify(i) + ':\n'), + (A += ' locations:\n'); + for (const t of n.locations) { + const r = o.y1.contains(e.cwd, t); + if (null === r) + throw new Error( + `Assertion failed: Expected the path to be within the project (${t})` + ); + A += ` - ${JSON.stringify(r)}\n`; + } + if (n.aliases.length > 0) { + A += ' aliases:\n'; + for (const e of n.aliases) + A += ` - ${JSON.stringify(e)}\n`; + } + if (i === s && r.size > 0) { + A += ' bin:\n'; + for (const [t, n] of r) { + const r = o.y1.contains(e.cwd, t); + if (null === r) + throw new Error( + `Assertion failed: Expected the path to be within the project (${t})` + ); + A += ` ${JSON.stringify(r)}:\n`; + for (const [e, r] of n) { + const n = o.y1.relative(o.y1.join(t, H), r); + A += ` ${JSON.stringify(e)}: ${JSON.stringify( + n + )}\n`; + } + } + } + } + const a = e.cwd, + c = o.y1.join(a, H, '.yarn-state.yml'); + await M.xfs.changeFilePromise(c, A, { + automaticNewlines: !0, + }); + })(A, t, r); + } finally { + E.stop(); + } + })(t, A, { + baseFs: e, + project: this.opts.project, + report: this.opts.report, + loadManifest: async (e) => { + const t = i.parseLocator(e), + r = this.localStore.get(t.locatorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the slot to exist' + ); + return r.customPackageData.manifest; + }, + }); + const n = []; + for (const [e, t] of A.entries()) { + if (Z(e)) continue; + const r = i.parseLocator(e), + A = this.localStore.get(r.locatorHash); + if (void 0 === A) + throw new Error('Assertion failed: Expected the slot to exist'); + const o = O.jsInstallUtils.extractBuildScripts( + A.pkg, + A.customPackageData, + A.dependencyMeta, + { + configuration: this.opts.project.configuration, + report: this.opts.report, + } + ); + 0 !== o.length && + n.push({ + buildLocations: t.locations, + locatorHash: r.locatorHash, + buildDirective: o, + }); + } + return { customData: this.customData, records: n }; + } + } + async function q(e, { unrollAliases: t = !1 } = {}) { + const r = e.cwd, + A = o.y1.join(r, H, '.yarn-state.yml'); + if (!M.xfs.existsSync(A)) return null; + const n = (0, P.parseSyml)(await M.xfs.readFilePromise(A, 'utf8')); + if (n.__metadata.version > 1) return null; + const s = new Map(), + a = new Map(); + delete n.__metadata; + for (const [e, A] of Object.entries(n)) { + const n = A.locations.map((e) => o.y1.join(r, e)), + c = A.bin; + if (c) + for (const [e, t] of Object.entries(c)) { + const A = o.y1.join(r, o.cS.toPortablePath(e)), + n = N.getMapWithDefault(a, A); + for (const [e, r] of Object.entries(t)) + n.set( + (0, o.Zu)(e), + o.cS.toPortablePath([A, H, r].join(o.y1.delimiter)) + ); + } + if ( + (s.set(e, { + target: o.LZ.dot, + linkType: k.Un.HARD, + locations: n, + aliases: A.aliases || [], + }), + t && A.aliases) + ) + for (const t of A.aliases) { + const { scope: r, name: A } = i.parseLocator(e), + a = i.makeLocator(i.makeIdent(r, A), t), + c = i.stringifyLocator(a); + s.set(c, { + target: o.LZ.dot, + linkType: k.Un.HARD, + locations: n, + aliases: [], + }); + } + } + return { + locatorMap: s, + binSymlinks: a, + locationTree: V(s, { skipPrefix: e.cwd }), + }; + } + const z = async (e, t) => { + if (e.split(o.y1.sep).indexOf(H) < 0) + throw new Error( + "Assertion failed: trying to remove dir that doesn't contain node_modules: " + + e + ); + try { + if (!t.innerLoop) { + if ((await M.xfs.lstatPromise(e)).isSymbolicLink()) + return void (await M.xfs.unlinkPromise(e)); + } + const r = await M.xfs.readdirPromise(e, { withFileTypes: !0 }); + for (const A of r) { + const r = o.y1.join(e, (0, o.Zu)(A.name)); + A.isDirectory() + ? (A.name !== H || (t && t.innerLoop)) && + (await z(r, { innerLoop: !0, contentsOnly: !1 })) + : await M.xfs.unlinkPromise(r); + } + t.contentsOnly || (await M.xfs.rmdirPromise(e)); + } catch (e) { + if ('ENOENT' !== e.code && 'ENOTEMPTY' !== e.code) throw e; + } + }, + W = (e, { skipPrefix: t }) => { + const r = o.y1.contains(t, e); + if (null === r) + throw new Error( + `Assertion failed: Cannot process a path that isn't part of the requested prefix (${e} isn't within ${t})` + ); + const A = r.split(o.y1.sep).filter((e) => '' !== e), + n = A.indexOf(H), + i = A.slice(0, n).join(o.y1.sep); + return { locationRoot: o.y1.join(t, i), segments: A.slice(n) }; + }, + V = (e, { skipPrefix: t }) => { + const r = new Map(); + if (null === e) return r; + const A = () => ({ children: new Map(), linkType: k.Un.HARD }); + for (const [n, i] of e.entries()) { + if (i.linkType === k.Un.SOFT) { + if (null !== o.y1.contains(t, i.target)) { + const e = N.getFactoryWithDefault(r, i.target, A); + (e.locator = n), (e.linkType = i.linkType); + } + } + for (const e of i.locations) { + const { locationRoot: o, segments: s } = W(e, { + skipPrefix: t, + }); + let a = N.getFactoryWithDefault(r, o, A); + for (let e = 0; e < s.length; ++e) { + const t = s[e]; + if ('.' !== t) { + const e = N.getFactoryWithDefault(a.children, t, A); + a.children.set(t, e), (a = e); + } + e === s.length - 1 && + ((a.locator = n), (a.linkType = i.linkType)); + } + } + } + return r; + }, + X = async (e, t) => { + let r; + try { + 'win32' === process.platform && (r = M.xfs.lstatSync(e)); + } catch (e) {} + 'win32' != process.platform || (r && !r.isDirectory()) + ? M.xfs.symlinkPromise(o.y1.relative(o.y1.dirname(t), e), t) + : M.xfs.symlinkPromise(e, t, 'junction'); + }, + _ = async (e, t, { baseFs: r, innerLoop: A }) => { + await M.xfs.mkdirPromise(e, { recursive: !0 }); + const n = await r.readdirPromise(t, { withFileTypes: !0 }), + i = async (e, t, A) => { + if (A.isFile()) { + const A = await r.lstatPromise(t); + await r.copyFilePromise(t, e); + const n = 511 & A.mode; + 420 !== n && (await M.xfs.chmodPromise(e, n)); + } else { + if (!A.isSymbolicLink()) + throw new Error( + `Unsupported file type (file: ${t}, mode: 0o${await M.xfs + .statSync(t) + .mode.toString(8) + .padStart(6, '0')})` + ); + { + const A = await r.readlinkPromise(t); + await X(o.y1.resolve(o.y1.dirname(e), A), e); + } + } + }; + for (const s of n) { + const n = o.y1.join(t, (0, o.Zu)(s.name)), + a = o.y1.join(e, (0, o.Zu)(s.name)); + s.isDirectory() + ? (s.name !== H || A) && + (await _(a, n, { baseFs: r, innerLoop: !0 })) + : await i(a, n, s); + } + }; + function Z(e) { + let t = i.parseDescriptor(e); + return ( + i.isVirtualDescriptor(t) && (t = i.devirtualizeDescriptor(t)), + t.range.startsWith('link:') + ); + } + const $ = (e, t) => { + if (!e || !t) return e === t; + let r = i.parseLocator(e); + i.isVirtualLocator(r) && (r = i.devirtualizeLocator(r)); + let A = i.parseLocator(t); + return ( + i.isVirtualLocator(A) && (A = i.devirtualizeLocator(A)), + i.areLocatorsEqual(r, A) + ); + }; + var ee = r(34432); + class te extends O.PnpLinker { + constructor() { + super(...arguments), (this.mode = 'loose'); + } + makeInstaller(e) { + return new re(e); + } + } + class re extends O.PnpInstaller { + constructor() { + super(...arguments), (this.mode = 'loose'); + } + async finalizeInstallWithPnp(e) { + if (this.opts.project.configuration.get('pnpMode') !== this.mode) + return; + const t = new R.p({ + baseFs: new x.A({ + libzip: await (0, L.getLibzipPromise)(), + maxOpenFiles: 80, + readOnlyArchives: !0, + }), + }), + r = (0, ee.oC)(e, this.opts.project.cwd, t), + A = Q(r, { pnpifyFs: !1, project: this.opts.project }), + n = new Map(); + e.fallbackPool = n; + const s = (e, t) => { + const r = i.parseLocator(t.locator), + A = i.stringifyIdent(r); + A === e ? n.set(e, r.reference) : n.set(e, [A, r.reference]); + }, + a = o.y1.join(this.opts.project.cwd, o.QS.nodeModules), + c = A.get(a); + if (void 0 === c) + throw new Error( + 'Assertion failed: Expected a root junction point' + ); + if ('target' in c) + throw new Error( + 'Assertion failed: Expected the root junction point to be a directory' + ); + for (const e of c.dirList) { + const t = o.y1.join(a, e), + r = A.get(t); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the child to have been registered' + ); + if ('target' in r) s(e, r); + else + for (const n of r.dirList) { + const r = o.y1.join(t, n), + i = A.get(r); + if (void 0 === i) + throw new Error( + 'Assertion failed: Expected the subchild to have been registered' + ); + if (!('target' in i)) + throw new Error( + 'Assertion failed: Expected the leaf junction to be a package' + ); + s(`${e}/${n}`, i); + } + } + return super.finalizeInstallWithPnp(e); + } + } + const Ae = (e) => o.y1.join(e.cwd, '.pnp.js'), + ne = { + configuration: { + nmHoistingLimits: { + description: + 'Prevent packages can be hoisted past specific levels', + type: n.a2.STRING, + values: [w.WORKSPACES, w.DEPENDENCIES, w.NONE], + default: 'none', + }, + }, + linkers: [ + class { + supportsPackage(e, t) { + return ( + 'node-modules' === t.project.configuration.get('nodeLinker') + ); + } + async findPackageLocation(e, t) { + const r = t.project.tryWorkspaceByLocator(e); + if (r) return r.cwd; + const A = await q(t.project, { unrollAliases: !0 }); + if (null === A) + throw new j.UsageError( + "Couldn't find the node_modules state file - running an install might help (findPackageLocation)" + ); + const n = A.locatorMap.get(i.stringifyLocator(e)); + if (!n) { + const r = new j.UsageError( + `Couldn't find ${i.prettyLocator( + t.project.configuration, + e + )} in the currently installed node_modules map - running an install might help` + ); + throw ((r.code = 'LOCATOR_NOT_INSTALLED'), r); + } + return n.locations[0]; + } + async findPackageLocator(e, t) { + const r = await q(t.project, { unrollAliases: !0 }); + if (null === r) return null; + const { locationRoot: A, segments: n } = W(o.y1.resolve(e), { + skipPrefix: t.project.cwd, + }); + let s = r.locationTree.get(A); + if (!s) return null; + let a = s.locator; + for (const e of n) { + if (((s = s.children.get(e)), !s)) break; + a = s.locator || a; + } + return i.parseLocator(a); + } + makeInstaller(e) { + return new J(e); + } + }, + te, + ], + }; + }, + 8190: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => X }); + var A, + n, + o = r(39922), + i = r(36370), + s = r(25413), + a = r(85824), + c = r(62152), + g = r(35691), + l = r(92659), + u = r(85875), + h = r(15815), + p = r(14224), + d = r(40822); + !(function (e) { + (e.All = 'all'), + (e.Production = 'production'), + (e.Development = 'development'); + })(A || (A = {})), + (function (e) { + (e.Info = 'info'), + (e.Low = 'low'), + (e.Moderate = 'moderate'), + (e.High = 'high'), + (e.Critical = 'critical'); + })(n || (n = {})); + var C = r(54143), + f = r(73632), + I = r(71643); + const E = [n.Info, n.Low, n.Moderate, n.High, n.Critical]; + function B(e, t) { + const r = [], + A = new Set(), + n = (e) => { + A.has(e) || (A.add(e), r.push(e)); + }; + for (const e of t) n(e); + const o = new Set(); + for (; r.length > 0; ) { + const t = r.shift(), + A = e.storedResolutions.get(t); + if (void 0 === A) + throw new Error( + 'Assertion failed: Expected the resolution to have been registered' + ); + const i = e.storedPackages.get(A); + if (i) { + o.add(t); + for (const e of i.dependencies.values()) n(e.descriptorHash); + } + } + return o; + } + function y(e, t, { all: r }) { + const A = r ? e.workspaces : [t], + n = A.map((e) => e.manifest), + o = new Set( + n.map((e) => [...e.dependencies].map(([e, t]) => e)).flat() + ), + i = new Set( + n.map((e) => [...e.devDependencies].map(([e, t]) => e)).flat() + ), + s = A.map((e) => [...e.dependencies.values()]).flat(), + a = s + .filter((e) => o.has(e.identHash)) + .map((e) => e.descriptorHash), + c = s + .filter((e) => i.has(e.identHash)) + .map((e) => e.descriptorHash), + g = B(e, a), + l = B(e, c); + return (u = l), (h = g), new Set([...u].filter((e) => !h.has(e))); + var u, h; + } + function m(e) { + const t = {}; + for (const r of e) + t[C.stringifyIdent(r)] = C.parseRange(r.range).selector; + return t; + } + function w(e) { + if (void 0 === e) return new Set(); + const t = E.indexOf(e), + r = E.slice(t); + return new Set(r); + } + function Q(e, t) { + var r; + const A = (function (e, t) { + const r = w(t), + A = {}; + for (const t of r) A[t] = e[t]; + return A; + })(e, t); + for (const e of Object.keys(A)) + if (null !== (r = A[e]) && void 0 !== r && r) return !0; + return !1; + } + class D extends s.BaseCommand { + constructor() { + super(...arguments), + (this.all = !1), + (this.recursive = !1), + (this.environment = A.All), + (this.json = !1), + (this.severity = n.Info); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await a.I.find( + e, + this.context.cwd + ); + if (!r) throw new s.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState(); + const n = (function (e, t, { all: r, environment: n }) { + const o = r ? e.workspaces : [t], + i = []; + if ([A.All, A.Production].includes(n)) + for (const e of o) + for (const t of e.manifest.dependencies.values()) i.push(t); + const s = []; + if ([A.All, A.Development].includes(n)) + for (const e of o) + for (const t of e.manifest.devDependencies.values()) + s.push(t); + return m( + [...i, ...s].filter( + (e) => null === C.parseRange(e.range).protocol + ) + ); + })(t, r, { all: this.all, environment: this.environment }), + i = (function (e, t, { all: r }) { + var A; + const n = y(e, t, { all: r }), + o = {}; + for (const t of e.storedPackages.values()) + o[C.stringifyIdent(t)] = { + version: + null !== (A = t.version) && void 0 !== A ? A : '0.0.0', + integrity: t.identHash, + requires: m(t.dependencies.values()), + dev: n.has(C.convertLocatorToDescriptor(t).descriptorHash), + }; + return o; + })(t, r, { all: this.all }); + if (!this.recursive) + for (const e of Object.keys(i)) + Object.prototype.hasOwnProperty.call(n, e) + ? (i[e].requires = {}) + : delete i[e]; + const d = { requires: n, dependencies: i }, + E = p.npmConfigUtils.getPublishRegistry(r.manifest, { + configuration: e, + }); + let B; + const D = await c.h.start( + { configuration: e, stdout: this.context.stdout }, + async () => { + try { + B = await p.npmHttpUtils.post( + '/-/npm/v1/security/audits/quick', + d, + { + authType: p.npmHttpUtils.AuthType.NO_AUTH, + configuration: e, + jsonResponse: !0, + registry: E, + } + ); + } catch (e) { + throw 'HTTPError' !== e.name + ? e + : new g.lk(l.b.EXCEPTION, e.toString()); + } + } + ); + if (D.hasErrors()) return D.exitCode(); + const b = Q(B.metadata.vulnerabilities, this.severity); + if (!this.json && b) + return ( + u.emitTree( + (function (e, t) { + const r = {}, + A = { children: r }; + let n = Object.values(e.advisories); + if (null != t) { + const e = w(t); + n = n.filter((t) => e.has(t.severity)); + } + for (const e of f.sortMap(n, (e) => e.module_name)) + r[e.module_name] = { + label: e.module_name, + value: I.tuple( + I.Type.RANGE, + e.findings.map((e) => e.version).join(', ') + ), + children: { + Issue: { + label: 'Issue', + value: I.tuple(I.Type.NO_HINT, e.title), + }, + URL: { + label: 'URL', + value: I.tuple(I.Type.URL, e.url), + }, + Severity: { + label: 'Severity', + value: I.tuple(I.Type.NO_HINT, e.severity), + }, + 'Vulnerable Versions': { + label: 'Vulnerable Versions', + value: I.tuple(I.Type.RANGE, e.vulnerable_versions), + }, + 'Patched Versions': { + label: 'Patched Versions', + value: I.tuple(I.Type.RANGE, e.patched_versions), + }, + Via: { + label: 'Via', + value: I.tuple( + I.Type.NO_HINT, + Array.from( + new Set( + e.findings + .map((e) => e.paths) + .flat() + .map((e) => e.split('>')[0]) + ) + ).join(', ') + ), + }, + Recommendation: { + label: 'Recommendation', + value: I.tuple( + I.Type.NO_HINT, + e.recommendation.replace(/\n/g, ' ') + ), + }, + }, + }; + return A; + })(B, this.severity), + { + configuration: e, + json: this.json, + stdout: this.context.stdout, + separators: 2, + } + ), + 1 + ); + return ( + await h.Pk.start( + { + configuration: e, + includeFooter: !1, + json: this.json, + stdout: this.context.stdout, + }, + async (e) => { + e.reportJson(B), + b || e.reportInfo(l.b.EXCEPTION, 'No audit suggestions'); + } + ) + ).exitCode(); + } + } + (D.usage = d.Command.Usage({ + description: + 'perform a vulnerability audit against the installed packages', + details: `\n This command checks for known security reports on the packages you use. The reports are by default extracted from the npm registry, and may or may not be relevant to your actual program (not all vulnerabilities affect all code paths).\n\n For consistency with our other commands the default is to only check the direct dependencies for the active workspace. To extend this search to all workspaces, use \`-A,--all\`. To extend this search to both direct and transitive dependencies, use \`-R,--recursive\`.\n\n Applying the \`--severity\` flag will limit the audit table to vulnerabilities of the corresponding severity and above. Valid values are ${E.map( + (e) => `\`${e}\`` + ).join( + ', ' + )}.\n\n If the \`--json\` flag is set, Yarn will print the output exactly as received from the registry. Regardless of this flag, the process will exit with a non-zero exit code if a report is found for the selected packages.\n\n To understand the dependency tree requiring vulnerable packages, check the raw report with the \`--json\` flag or use \`yarn why \` to get more information as to who depends on them.\n `, + examples: [ + [ + 'Checks for known security issues with the installed packages. The output is a list of known issues.', + 'yarn npm audit', + ], + ['Audit dependencies in all workspaces', 'yarn npm audit --all'], + [ + 'Limit auditing to `dependencies` (excludes `devDependencies`)', + 'yarn npm audit --environment production', + ], + ['Show audit report as valid JSON', 'yarn npm audit --json'], + [ + 'Audit all direct and transitive dependencies', + 'yarn npm audit --recursive', + ], + [ + 'Output moderate (or more severe) vulnerabilities', + 'yarn npm audit --severity moderate', + ], + ], + })), + (0, i.gn)( + [d.Command.Boolean('-A,--all')], + D.prototype, + 'all', + void 0 + ), + (0, i.gn)( + [d.Command.Boolean('-R,--recursive')], + D.prototype, + 'recursive', + void 0 + ), + (0, i.gn)( + [d.Command.String('--environment')], + D.prototype, + 'environment', + void 0 + ), + (0, i.gn)([d.Command.Boolean('--json')], D.prototype, 'json', void 0), + (0, i.gn)( + [d.Command.String('--severity')], + D.prototype, + 'severity', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'audit')], + D.prototype, + 'execute', + null + ); + var b = r(85622), + v = r.n(b), + S = r(53887), + k = r.n(S), + N = r(31669); + class F extends s.BaseCommand { + constructor() { + super(...arguments), (this.json = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t } = await a.I.find(e, this.context.cwd), + r = + void 0 !== this.fields + ? new Set(['name', ...this.fields.split(/\s*,\s*/)]) + : null, + A = []; + let n = !1; + const i = await h.Pk.start( + { + configuration: e, + includeFooter: !1, + json: this.json, + stdout: this.context.stdout, + }, + async (o) => { + for (const i of this.packages) { + let s; + if ('.' === i) { + const e = t.topLevelWorkspace; + if (!e.manifest.name) + throw new d.UsageError( + "Missing 'name' field in " + + v().join(e.cwd, 'package.json') + ); + s = C.makeDescriptor(e.manifest.name, 'unknown'); + } else s = C.parseDescriptor(i); + const a = p.npmHttpUtils.getIdentUrl(s); + let c; + try { + c = K( + await p.npmHttpUtils.get(a, { + configuration: e, + ident: s, + jsonResponse: !0, + }) + ); + } catch (e) { + throw 'HTTPError' !== e.name + ? e + : 404 === e.response.statusCode + ? new g.lk(l.b.EXCEPTION, 'Package not found') + : new g.lk(l.b.EXCEPTION, e.toString()); + } + const u = Object.keys(c.versions).sort(k().compareLoose); + let h = c['dist-tags'].latest || u[u.length - 1]; + if (k().validRange(s.range)) { + const t = k().maxSatisfying(u, s.range); + null !== t + ? (h = t) + : (o.reportWarning( + l.b.UNNAMED, + `Unmet range ${C.prettyRange( + e, + s.range + )}; falling back to the latest version` + ), + (n = !0)); + } else + 'unknown' !== s.range && + (o.reportWarning( + l.b.UNNAMED, + `Invalid range ${C.prettyRange( + e, + s.range + )}; falling back to the latest version` + ), + (n = !0)); + const f = c.versions[h], + I = { ...c, ...f, version: h, versions: u }; + let E; + if (null !== r) { + E = {}; + for (const t of r) { + const r = I[t]; + void 0 !== r + ? (E[t] = r) + : (o.reportWarning( + l.b.EXCEPTION, + `The '${t}' field doesn't exist inside ${C.prettyIdent( + e, + s + )}'s informations` + ), + (n = !0)); + } + } else + this.json || + (delete I.dist, delete I.readme, delete I.users), + (E = I); + o.reportJson(E), this.json || A.push(E); + } + } + ); + N.inspect.styles.name = 'cyan'; + for (const e of A) + (e !== A[0] || n) && this.context.stdout.write('\n'), + this.context.stdout.write( + (0, N.inspect)(e, { depth: 1 / 0, colors: !0, compact: !1 }) + + '\n' + ); + return i.exitCode(); + } + } + function K(e) { + if (Array.isArray(e)) { + const t = []; + for (let r of e) (r = K(r)), r && t.push(r); + return t; + } + if ('object' == typeof e && null !== e) { + const t = {}; + for (const r of Object.keys(e)) { + if (r.startsWith('_')) continue; + const A = K(e[r]); + A && (t[r] = A); + } + return t; + } + return e || null; + } + (F.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'show information about a package', + details: + "\n This command will fetch information about a package from the npm registry, and prints it in a tree format.\n\n The package does not have to be installed locally, but needs to have been published (in particular, local changes will be ignored even for workspaces).\n\n Append `@` to the package argument to provide information specific to the latest version that satisfies the range. If the range is invalid or if there is no version satisfying the range, the command will print a warning and fall back to the latest version.\n\n If the `-f,--fields` option is set, it's a comma-separated list of fields which will be used to only display part of the package informations.\n\n By default, this command won't return the `dist`, `readme`, and `users` fields, since they are often very long. To explicitly request those fields, explicitly list them with the `--fields` flag or request the output in JSON mode.\n ", + examples: [ + [ + 'Show all available information about react (except the `dist`, `readme`, and `users` fields)', + 'yarn npm info react', + ], + [ + 'Show all available information about react as valid JSON (including the `dist`, `readme`, and `users` fields)', + 'yarn npm info react --json', + ], + [ + 'Show all available information about react 16.12.0', + 'yarn npm info react@16.12.0', + ], + [ + 'Show the description of react', + 'yarn npm info react --fields description', + ], + [ + 'Show all available versions of react', + 'yarn npm info react --fields versions', + ], + ['Show the readme of react', 'yarn npm info react --fields readme'], + [ + 'Show a few fields of react', + 'yarn npm info react --fields homepage,repository', + ], + ], + })), + (0, i.gn)([d.Command.Rest()], F.prototype, 'packages', void 0), + (0, i.gn)( + [ + d.Command.String('-f,--fields', { + description: + 'A comma-separated list of manifest fields that should be displayed', + }), + ], + F.prototype, + 'fields', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + F.prototype, + 'json', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'info')], + F.prototype, + 'execute', + null + ); + var M = r(61899); + class R extends s.BaseCommand { + constructor() { + super(...arguments), (this.publish = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + t = await x({ + configuration: e, + cwd: this.context.cwd, + publish: this.publish, + scope: this.scope, + }); + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + const A = await (async function ({ + registry: e, + report: t, + stdin: r, + stdout: A, + }) { + if (process.env.TEST_ENV) + return { + name: process.env.TEST_NPM_USER || '', + password: process.env.TEST_NPM_PASSWORD || '', + }; + t.reportInfo(l.b.UNNAMED, 'Logging in to ' + e); + let n = !1; + e.match(/^https:\/\/npm\.pkg\.github\.com(\/|$)/) && + (t.reportInfo( + l.b.UNNAMED, + "You seem to be using the GitHub Package Registry. Tokens must be generated with the 'repo', 'write:packages', and 'read:packages' permissions." + ), + (n = !0)); + t.reportSeparator(); + const { username: o, password: i } = await (0, M.prompt)([ + { + type: 'input', + name: 'username', + message: 'Username:', + required: !0, + onCancel: () => process.exit(130), + stdin: r, + stdout: A, + }, + { + type: 'password', + name: 'password', + message: n ? 'Token:' : 'Password:', + required: !0, + onCancel: () => process.exit(130), + stdin: r, + stdout: A, + }, + ]); + return t.reportSeparator(), { name: o, password: i }; + })({ + registry: t, + report: r, + stdin: this.context.stdin, + stdout: this.context.stdout, + }), + n = + '/-/user/org.couchdb.user:' + encodeURIComponent(A.name), + i = await p.npmHttpUtils.put(n, A, { + attemptedAs: A.name, + configuration: e, + registry: t, + jsonResponse: !0, + authType: p.npmHttpUtils.AuthType.NO_AUTH, + }); + return ( + await (async function ( + e, + t, + { configuration: r, scope: A } + ) { + const n = (e) => (r) => { + const A = f.isIndexableObject(r) ? r : {}, + n = A[e], + o = f.isIndexableObject(n) ? n : {}; + return { ...A, [e]: { ...o, npmAuthToken: t } }; + }, + i = A ? { npmScopes: n(A) } : { npmRegistries: n(e) }; + return await o.VK.updateHomeConfiguration(i); + })(t, i.token, { configuration: e, scope: this.scope }), + r.reportInfo(l.b.UNNAMED, 'Successfully logged in') + ); + } + ) + ).exitCode(); + } + } + async function x({ scope: e, publish: t, configuration: r, cwd: A }) { + return e && t + ? p.npmConfigUtils.getScopeRegistry(e, { + configuration: r, + type: p.npmConfigUtils.RegistryType.PUBLISH_REGISTRY, + }) + : e + ? p.npmConfigUtils.getScopeRegistry(e, { configuration: r }) + : t + ? p.npmConfigUtils.getPublishRegistry( + (await (0, s.openWorkspace)(r, A)).manifest, + { configuration: r } + ) + : p.npmConfigUtils.getDefaultRegistry({ configuration: r }); + } + (R.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'store new login info to access the npm registry', + details: + '\n This command will ask you for your username, password, and 2FA One-Time-Password (when it applies). It will then modify your local configuration (in your home folder, never in the project itself) to reference the new tokens thus generated.\n\n Adding the `-s,--scope` flag will cause the authentication to be done against whatever registry is configured for the associated scope (see also `npmScopes`).\n\n Adding the `--publish` flag will cause the authentication to be done against the registry used when publishing the package (see also `publishConfig.registry` and `npmPublishRegistry`).\n ', + examples: [ + ['Login to the default registry', 'yarn npm login'], + [ + 'Login to the registry linked to the @my-scope registry', + 'yarn npm login --scope my-scope', + ], + [ + 'Login to the publish registry for the current package', + 'yarn npm login --publish', + ], + ], + })), + (0, i.gn)( + [ + d.Command.String('-s,--scope', { + description: + 'Login to the registry configured for a given scope', + }), + ], + R.prototype, + 'scope', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--publish', { + description: 'Login to the publish registry', + }), + ], + R.prototype, + 'publish', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'login')], + R.prototype, + 'execute', + null + ); + const L = new Set(['npmAuthIdent', 'npmAuthToken']); + class P extends s.BaseCommand { + constructor() { + super(...arguments), (this.publish = !1), (this.all = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + t = async () => { + var t; + const r = await x({ + configuration: e, + cwd: this.context.cwd, + publish: this.publish, + scope: this.scope, + }), + A = await o.VK.find(this.context.cwd, this.context.plugins), + n = C.makeIdent( + null !== (t = this.scope) && void 0 !== t ? t : null, + 'pkg' + ); + return !p.npmConfigUtils + .getAuthConfiguration(r, { configuration: A, ident: n }) + .get('npmAuthToken'); + }; + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + if ( + (this.all && + (await (async function () { + const e = (e) => { + let t = !1; + const r = f.isIndexableObject(e) ? { ...e } : {}; + r.npmAuthToken && (delete r.npmAuthToken, (t = !0)); + for (const e of Object.keys(r)) O(r, e) && (t = !0); + if (0 !== Object.keys(r).length) return t ? r : e; + }; + return await o.VK.updateHomeConfiguration({ + npmRegistries: e, + npmScopes: e, + }); + })(), + r.reportInfo( + l.b.UNNAMED, + 'Successfully logged out from everything' + )), + this.scope) + ) + return ( + await U('npmScopes', this.scope), + void ((await t()) + ? r.reportInfo( + l.b.UNNAMED, + 'Successfully logged out from ' + this.scope + ) + : r.reportWarning( + l.b.UNNAMED, + 'Scope authentication settings removed, but some other ones settings still apply to it' + )) + ); + const A = await x({ + configuration: e, + cwd: this.context.cwd, + publish: this.publish, + }); + await U('npmRegistries', A), + (await t()) + ? r.reportInfo( + l.b.UNNAMED, + 'Successfully logged out from ' + A + ) + : r.reportWarning( + l.b.UNNAMED, + 'Registry authentication settings removed, but some other ones settings still apply to it' + ); + } + ) + ).exitCode(); + } + } + function O(e, t) { + const r = e[t]; + if (!f.isIndexableObject(r)) return !1; + const A = new Set(Object.keys(r)); + if ([...L].every((e) => !A.has(e))) return !1; + for (const e of L) A.delete(e); + if (0 === A.size) return (e[t] = void 0), !0; + const n = { ...r }; + for (const e of L) delete n[e]; + return (e[t] = n), !0; + } + async function U(e, t) { + return await o.VK.updateHomeConfiguration({ + [e]: (e) => { + const r = f.isIndexableObject(e) ? e : {}; + if (!Object.prototype.hasOwnProperty.call(r, t)) return e; + const A = r[t], + n = f.isIndexableObject(A) ? A : {}, + o = new Set(Object.keys(n)); + if ([...L].every((e) => !o.has(e))) return e; + for (const e of L) o.delete(e); + if (0 === o.size) { + if (1 === Object.keys(r).length) return; + return { ...r, [t]: void 0 }; + } + const i = {}; + for (const e of L) i[e] = void 0; + return { ...r, [t]: { ...n, ...i } }; + }, + }); + } + (P.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'logout of the npm registry', + details: + '\n This command will log you out by modifying your local configuration (in your home folder, never in the project itself) to delete all credentials linked to a registry.\n\n Adding the `-s,--scope` flag will cause the deletion to be done against whatever registry is configured for the associated scope (see also `npmScopes`).\n\n Adding the `--publish` flag will cause the deletion to be done against the registry used when publishing the package (see also `publishConfig.registry` and `npmPublishRegistry`).\n\n Adding the `-A,--all` flag will cause the deletion to be done against all registries and scopes.\n ', + examples: [ + ['Logout of the default registry', 'yarn npm logout'], + [ + 'Logout of the @my-scope scope', + 'yarn npm logout --scope my-scope', + ], + [ + 'Logout of the publish registry for the current package', + 'yarn npm logout --publish', + ], + ['Logout of all registries', 'yarn npm logout --all'], + ], + })), + (0, i.gn)( + [ + d.Command.String('-s,--scope', { + description: + 'Logout of the registry configured for a given scope', + }), + ], + P.prototype, + 'scope', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--publish', { + description: 'Logout of the publish registry', + }), + ], + P.prototype, + 'publish', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('-A,--all', { + description: 'Logout of all registries', + }), + ], + P.prototype, + 'all', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'logout')], + P.prototype, + 'execute', + null + ); + var T = r(63088), + j = r(49881); + class Y extends s.BaseCommand { + constructor() { + super(...arguments), + (this.tag = 'latest'), + (this.tolerateRepublish = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await a.I.find( + e, + this.context.cwd + ); + if (!r) throw new s.WorkspaceRequiredError(t.cwd, this.context.cwd); + if (r.manifest.private) + throw new d.UsageError('Private workspaces cannot be published'); + if (null === r.manifest.name || null === r.manifest.version) + throw new d.UsageError( + 'Workspaces must have valid names and versions to be published on an external registry' + ); + await t.restoreInstallState(); + const A = r.manifest.name, + n = r.manifest.version, + i = p.npmConfigUtils.getPublishRegistry(r.manifest, { + configuration: e, + }); + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (t) => { + if (this.tolerateRepublish) + try { + const r = await p.npmHttpUtils.get( + p.npmHttpUtils.getIdentUrl(A), + { + configuration: e, + registry: i, + ident: A, + jsonResponse: !0, + } + ); + if (!Object.prototype.hasOwnProperty.call(r, 'versions')) + throw new g.lk( + l.b.REMOTE_INVALID, + 'Registry returned invalid data for - missing "versions" field' + ); + if (Object.prototype.hasOwnProperty.call(r.versions, n)) + return void t.reportWarning( + l.b.UNNAMED, + `Registry already knows about version ${n}; skipping.` + ); + } catch (e) { + if ('HTTPError' !== e.name) throw e; + if (404 !== e.response.statusCode) + throw new g.lk( + l.b.NETWORK_ERROR, + `The remote server answered with HTTP ${e.response.statusCode} ${e.response.statusMessage}` + ); + } + await T.maybeExecuteWorkspaceLifecycleScript( + r, + 'prepublish', + { report: t } + ), + await j.packUtils.prepareForPack( + r, + { report: t }, + async () => { + const n = await j.packUtils.genPackList(r); + for (const e of n) t.reportInfo(null, e); + const o = await j.packUtils.genPackStream(r, n), + s = await f.bufferStream(o), + a = await p.npmPublishUtils.makePublishBody(r, s, { + access: this.access, + tag: this.tag, + registry: i, + }); + try { + await p.npmHttpUtils.put( + p.npmHttpUtils.getIdentUrl(A), + a, + { + configuration: e, + registry: i, + ident: A, + jsonResponse: !0, + } + ); + } catch (e) { + if ('HTTPError' !== e.name) throw e; + { + const r = + e.response.body && e.response.body.error + ? e.response.body.error + : `The remote server answered with HTTP ${e.response.statusCode} ${e.response.statusMessage}`; + t.reportError(l.b.NETWORK_ERROR, r); + } + } + } + ), + t.hasErrors() || + t.reportInfo(l.b.UNNAMED, 'Package archive published'); + } + ) + ).exitCode(); + } + } + (Y.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'publish the active workspace to the npm registry', + details: + '\n This command will pack the active workspace into a fresh archive and upload it to the npm registry.\n\n The package will by default be attached to the `latest` tag on the registry, but this behavior can be overriden by using the `--tag` option.\n\n Note that for legacy reasons scoped packages are by default published with an access set to `restricted` (aka "private packages"). This requires you to register for a paid npm plan. In case you simply wish to publish a public scoped package to the registry (for free), just add the `--access public` flag. This behavior can be enabled by default through the `npmPublishAccess` settings.\n ', + examples: [['Publish the active workspace', 'yarn npm publish']], + })), + (0, i.gn)( + [ + d.Command.String('--access', { + description: + 'The access for the published package (public or restricted)', + }), + ], + Y.prototype, + 'access', + void 0 + ), + (0, i.gn)( + [ + d.Command.String('--tag', { + description: + 'The tag on the registry that the package should be attached to', + }), + ], + Y.prototype, + 'tag', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--tolerate-republish', { + description: + 'Warn and exit when republishing an already existing version of a package', + }), + ], + Y.prototype, + 'tolerateRepublish', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'publish')], + Y.prototype, + 'execute', + null + ); + var G = r(46009); + class H extends s.BaseCommand { + constructor() { + super(...arguments), (this.json = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await a.I.find( + e, + this.context.cwd + ); + let A; + if (void 0 !== this.package) A = C.parseIdent(this.package); + else { + if (!r) + throw new s.WorkspaceRequiredError(t.cwd, this.context.cwd); + if (!r.manifest.name) + throw new d.UsageError( + "Missing 'name' field in " + G.y1.join(r.cwd, G.QS.manifest) + ); + A = r.manifest.name; + } + const n = await J(A, e), + i = { + children: f + .sortMap(Object.entries(n), ([e]) => e) + .map(([e, t]) => ({ + value: I.tuple(I.Type.RESOLUTION, { + descriptor: C.makeDescriptor(A, e), + locator: C.makeLocator(A, t), + }), + })), + }; + return u.emitTree(i, { + configuration: e, + json: this.json, + stdout: this.context.stdout, + }); + } + } + async function J(e, t) { + const r = `/-/package${p.npmHttpUtils.getIdentUrl(e)}/dist-tags`; + return p.npmHttpUtils + .get(r, { configuration: t, ident: e, jsonResponse: !0 }) + .catch((e) => { + throw 'HTTPError' !== e.name + ? e + : 404 === e.response.statusCode + ? new g.lk(l.b.EXCEPTION, 'Package not found') + : new g.lk(l.b.EXCEPTION, e.toString()); + }); + } + (H.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'list all dist-tags of a package', + details: + '\n This command will list all tags of a package from the npm registry.\n\n If the package is not specified, Yarn will default to the current workspace.\n ', + examples: [ + ['List all tags of package `my-pkg`', 'yarn npm tag list my-pkg'], + ], + })), + (0, i.gn)( + [d.Command.String({ required: !1 })], + H.prototype, + 'package', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + H.prototype, + 'json', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'tag', 'list')], + H.prototype, + 'execute', + null + ); + class q extends s.BaseCommand { + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await a.I.find( + e, + this.context.cwd + ); + if (!r) throw new s.WorkspaceRequiredError(t.cwd, this.context.cwd); + const A = C.parseDescriptor(this.package, !0), + n = A.range; + if (!k().valid(n)) + throw new d.UsageError( + `The range ${I.pretty( + e, + A.range, + I.Type.RANGE + )} must be a valid semver version` + ); + const i = p.npmConfigUtils.getPublishRegistry(r.manifest, { + configuration: e, + }), + c = I.pretty(e, A, I.Type.IDENT), + g = I.pretty(e, n, I.Type.RANGE), + u = I.pretty(e, this.tag, I.Type.CODE); + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (t) => { + const r = await J(A, e); + Object.prototype.hasOwnProperty.call(r, this.tag) && + r[this.tag] === n && + t.reportWarning( + l.b.UNNAMED, + `Tag ${u} is already set to version ${g}` + ); + try { + const t = `/-/package${p.npmHttpUtils.getIdentUrl( + A + )}/dist-tags/${encodeURIComponent(this.tag)}`; + await p.npmHttpUtils.put(t, n, { + configuration: e, + registry: i, + ident: A, + jsonRequest: !0, + jsonResponse: !0, + }); + } catch (e) { + if ('HTTPError' !== e.name) throw e; + { + const r = + e.response.body && e.response.body.error + ? e.response.body.error + : `The remote server answered with HTTP ${e.response.statusCode} ${e.response.statusMessage}`; + t.reportError(l.b.NETWORK_ERROR, r); + } + } + t.hasErrors() || + t.reportInfo( + l.b.UNNAMED, + `Tag ${u} added to version ${g} of package ${c}` + ); + } + ) + ).exitCode(); + } + } + (q.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'add a tag for a specific version of a package', + details: + '\n This command will add a tag to the npm registry for a specific version of a package. If the tag already exists, it will be overwritten.\n ', + examples: [ + [ + 'Add a `beta` tag for version `2.3.4-beta.4` of package `my-pkg`', + 'yarn npm tag add my-pkg@2.3.4-beta.4 beta', + ], + ], + })), + (0, i.gn)([d.Command.String()], q.prototype, 'package', void 0), + (0, i.gn)([d.Command.String()], q.prototype, 'tag', void 0), + (0, i.gn)( + [d.Command.Path('npm', 'tag', 'add')], + q.prototype, + 'execute', + null + ); + var z = r(15966); + class W extends s.BaseCommand { + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await a.I.find( + e, + this.context.cwd + ); + if (!r) throw new s.WorkspaceRequiredError(t.cwd, this.context.cwd); + const A = C.parseIdent(this.package), + n = p.npmConfigUtils.getPublishRegistry(r.manifest, { + configuration: e, + }), + i = I.pretty(e, this.tag, I.Type.CODE), + c = I.pretty(e, A, I.Type.IDENT), + g = await J(A, e); + if (!Object.prototype.hasOwnProperty.call(g, this.tag)) + throw new d.UsageError(`${i} is not a tag of package ${c}`); + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (t) => { + try { + const t = `/-/package${p.npmHttpUtils.getIdentUrl( + A + )}/dist-tags/${encodeURIComponent(this.tag)}`; + await p.npmHttpUtils.del(t, { + configuration: e, + registry: n, + ident: A, + jsonResponse: !0, + }); + } catch (e) { + if ('HTTPError' !== e.name) throw e; + { + const r = + e.response.body && e.response.body.error + ? e.response.body.error + : `The remote server answered with HTTP ${e.response.statusCode} ${e.response.statusMessage}`; + t.reportError(l.b.NETWORK_ERROR, r); + } + } + t.hasErrors() || + t.reportInfo( + l.b.UNNAMED, + `Tag ${i} removed from package ${c}` + ); + } + ) + ).exitCode(); + } + } + (W.schema = z.object().shape({ tag: z.string().notOneOf(['latest']) })), + (W.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'remove a tag from a package', + details: + '\n This command will remove a tag from a package from the npm registry.\n ', + examples: [ + [ + 'Remove the `beta` tag from package `my-pkg`', + 'yarn npm tag remove my-pkg beta', + ], + ], + })), + (0, i.gn)([d.Command.String()], W.prototype, 'package', void 0), + (0, i.gn)([d.Command.String()], W.prototype, 'tag', void 0), + (0, i.gn)( + [d.Command.Path('npm', 'tag', 'remove')], + W.prototype, + 'execute', + null + ); + class V extends s.BaseCommand { + constructor() { + super(...arguments), (this.publish = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins); + let t; + t = + this.scope && this.publish + ? p.npmConfigUtils.getScopeRegistry(this.scope, { + configuration: e, + type: p.npmConfigUtils.RegistryType.PUBLISH_REGISTRY, + }) + : this.scope + ? p.npmConfigUtils.getScopeRegistry(this.scope, { + configuration: e, + }) + : this.publish + ? p.npmConfigUtils.getPublishRegistry( + (await (0, s.openWorkspace)(e, this.context.cwd)).manifest, + { configuration: e } + ) + : p.npmConfigUtils.getDefaultRegistry({ configuration: e }); + return ( + await h.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + try { + const A = await p.npmHttpUtils.get('/-/whoami', { + configuration: e, + registry: t, + authType: p.npmHttpUtils.AuthType.ALWAYS_AUTH, + jsonResponse: !0, + ident: this.scope ? C.makeIdent(this.scope, '') : void 0, + }); + r.reportInfo(l.b.UNNAMED, A.username); + } catch (e) { + if ('HTTPError' !== e.name) throw e; + 401 === e.response.statusCode || + 403 === e.response.statusCode + ? r.reportError( + l.b.AUTHENTICATION_INVALID, + 'Authentication failed - your credentials may have expired' + ) + : r.reportError(l.b.AUTHENTICATION_INVALID, e.toString()); + } + } + ) + ).exitCode(); + } + } + (V.usage = d.Command.Usage({ + category: 'Npm-related commands', + description: 'display the name of the authenticated user', + details: + "\n Print the username associated with the current authentication settings to the standard output.\n\n When using `-s,--scope`, the username printed will be the one that matches the authentication settings of the registry associated with the given scope (those settings can be overriden using the `npmRegistries` map, and the registry associated with the scope is configured via the `npmScopes` map).\n\n When using `--publish`, the registry we'll select will by default be the one used when publishing packages (`publishConfig.registry` or `npmPublishRegistry` if available, otherwise we'll fallback to the regular `npmRegistryServer`).\n ", + examples: [ + ['Print username for the default registry', 'yarn npm whoami'], + [ + 'Print username for the registry on a given scope', + 'yarn npm whoami --scope company', + ], + ], + })), + (0, i.gn)( + [ + d.Command.String('-s,--scope', { + description: + 'Print username for the registry configured for a given scope', + }), + ], + V.prototype, + 'scope', + void 0 + ), + (0, i.gn)( + [ + d.Command.Boolean('--publish', { + description: 'Print username for the publish registry', + }), + ], + V.prototype, + 'publish', + void 0 + ), + (0, i.gn)( + [d.Command.Path('npm', 'whoami')], + V.prototype, + 'execute', + null + ); + const X = { + configuration: { + npmPublishAccess: { + description: 'Default access of the published packages', + type: o.a2.STRING, + default: null, + }, + }, + commands: [D, F, R, P, Y, q, H, W, V], + }; + }, + 14224: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + default: () => W, + npmConfigUtils: () => A, + npmHttpUtils: () => n, + npmPublishUtils: () => o, + }); + var A = {}; + r.r(A), + r.d(A, { + RegistryType: () => l, + getAuthConfiguration: () => Q, + getDefaultRegistry: () => y, + getPublishRegistry: () => E, + getRegistryConfiguration: () => m, + getScopeConfiguration: () => w, + getScopeRegistry: () => B, + normalizeRegistry: () => I, + }); + var n = {}; + r.r(n), + r.d(n, { + AuthType: () => u, + del: () => N, + get: () => v, + getIdentUrl: () => b, + handleInvalidAuthenticationError: () => D, + post: () => S, + put: () => k, + }); + var o = {}; + r.r(o), r.d(o, { makePublishBody: () => J }); + var i = r(39922), + s = r(54143), + a = r(72785), + c = r(53887), + g = r.n(c); + var l, + u, + h = r(79669), + p = r(35691), + d = r(92659), + C = r(61899), + f = r(78835); + function I(e) { + return e.replace(/\/$/, ''); + } + function E(e, { configuration: t }) { + return e.publishConfig && e.publishConfig.registry + ? I(e.publishConfig.registry) + : e.name + ? B(e.name.scope, { configuration: t, type: l.PUBLISH_REGISTRY }) + : y({ configuration: t, type: l.PUBLISH_REGISTRY }); + } + function B(e, { configuration: t, type: r = l.FETCH_REGISTRY }) { + const A = w(e, { configuration: t }); + if (null === A) return y({ configuration: t, type: r }); + const n = A.get(r); + return null === n ? y({ configuration: t, type: r }) : I(n); + } + function y({ configuration: e, type: t = l.FETCH_REGISTRY }) { + const r = e.get(t); + return I(null !== r ? r : e.get(l.FETCH_REGISTRY)); + } + function m(e, { configuration: t }) { + const r = t.get('npmRegistries'), + A = r.get(e); + if (void 0 !== A) return A; + const n = r.get(e.replace(/^[a-z]+:/, '')); + return void 0 !== n ? n : null; + } + function w(e, { configuration: t }) { + if (null === e) return null; + const r = t.get('npmScopes').get(e); + return r || null; + } + function Q(e, { configuration: t, ident: r }) { + const A = r && w(r.scope, { configuration: t }); + if ( + (null == A ? void 0 : A.get('npmAuthIdent')) || + (null == A ? void 0 : A.get('npmAuthToken')) + ) + return A; + return m(e, { configuration: t }) || t; + } + async function D( + e, + { attemptedAs: t, registry: r, headers: A, configuration: n } + ) { + if ('HTTPError' === e.name && 401 === e.response.statusCode) + throw new p.lk( + d.b.AUTHENTICATION_INVALID, + `Invalid authentication (${ + 'string' != typeof t + ? 'as ' + + (await (async function (e, t, { configuration: r }) { + var A; + if (void 0 === t || void 0 === t.authorization) + return 'an anonymous user'; + try { + const n = await h.get(new f.URL(e + '/-/whoami').href, { + configuration: r, + headers: t, + jsonResponse: !0, + }); + return null !== (A = n.username) && void 0 !== A + ? A + : 'an unknown user'; + } catch (e) { + return 'an unknown user'; + } + })(r, A, { configuration: n })) + : 'attempted as ' + t + })` + ); + } + function b(e) { + return e.scope ? `/@${e.scope}%2f${e.name}` : '/' + e.name; + } + async function v( + e, + { + configuration: t, + headers: r, + ident: A, + authType: n, + registry: o, + ...i + } + ) { + if ( + (A && void 0 === o && (o = B(A.scope, { configuration: t })), + A && A.scope && void 0 === n && (n = u.BEST_EFFORT), + 'string' != typeof o) + ) + throw new Error( + 'Assertion failed: The registry should be a string' + ); + const s = F(o, { authType: n, configuration: t, ident: A }); + let a; + s && (r = { ...r, authorization: s }); + try { + a = new f.URL(e); + } catch (t) { + a = new f.URL(o + e); + } + try { + return await h.get(a.href, { configuration: t, headers: r, ...i }); + } catch (e) { + throw ( + (await D(e, { registry: o, configuration: t, headers: r }), e) + ); + } + } + async function S( + e, + t, + { + attemptedAs: r, + configuration: A, + headers: n, + ident: o, + authType: i = u.ALWAYS_AUTH, + registry: s, + ...a + } + ) { + if ( + (o && void 0 === s && (s = B(o.scope, { configuration: A })), + 'string' != typeof s) + ) + throw new Error( + 'Assertion failed: The registry should be a string' + ); + const c = F(s, { authType: i, configuration: A, ident: o }); + c && (n = { ...n, authorization: c }); + try { + return await h.post(s + e, t, { + configuration: A, + headers: n, + ...a, + }); + } catch (o) { + if (!M(o)) + throw ( + (await D(o, { + attemptedAs: r, + registry: s, + configuration: A, + headers: n, + }), + o) + ); + const i = await K(), + c = { ...n, ...R(i) }; + try { + return await h.post(`${s}${e}`, t, { + configuration: A, + headers: c, + ...a, + }); + } catch (e) { + throw ( + (await D(e, { + attemptedAs: r, + registry: s, + configuration: A, + headers: n, + }), + e) + ); + } + } + } + async function k( + e, + t, + { + attemptedAs: r, + configuration: A, + headers: n, + ident: o, + authType: i = u.ALWAYS_AUTH, + registry: s, + ...a + } + ) { + if ( + (o && void 0 === s && (s = B(o.scope, { configuration: A })), + 'string' != typeof s) + ) + throw new Error( + 'Assertion failed: The registry should be a string' + ); + const c = F(s, { authType: i, configuration: A, ident: o }); + c && (n = { ...n, authorization: c }); + try { + return await h.put(s + e, t, { + configuration: A, + headers: n, + ...a, + }); + } catch (o) { + if (!M(o)) + throw ( + (await D(o, { + attemptedAs: r, + registry: s, + configuration: A, + headers: n, + }), + o) + ); + const i = await K(), + c = { ...n, ...R(i) }; + try { + return await h.put(`${s}${e}`, t, { + configuration: A, + headers: c, + ...a, + }); + } catch (e) { + throw ( + (await D(e, { + attemptedAs: r, + registry: s, + configuration: A, + headers: n, + }), + e) + ); + } + } + } + async function N( + e, + { + attemptedAs: t, + configuration: r, + headers: A, + ident: n, + authType: o = u.ALWAYS_AUTH, + registry: i, + ...s + } + ) { + if ( + (n && void 0 === i && (i = B(n.scope, { configuration: r })), + 'string' != typeof i) + ) + throw new Error( + 'Assertion failed: The registry should be a string' + ); + const a = F(i, { authType: o, configuration: r, ident: n }); + a && (A = { ...A, authorization: a }); + try { + return await h.del(i + e, { configuration: r, headers: A, ...s }); + } catch (n) { + if (!M(n)) + throw ( + (await D(n, { + attemptedAs: t, + registry: i, + configuration: r, + headers: A, + }), + n) + ); + const o = await K(), + a = { ...A, ...R(o) }; + try { + return await h.del(`${i}${e}`, { + configuration: r, + headers: a, + ...s, + }); + } catch (e) { + throw ( + (await D(e, { + attemptedAs: t, + registry: i, + configuration: r, + headers: A, + }), + e) + ); + } + } + } + function F( + e, + { authType: t = u.CONFIGURATION, configuration: r, ident: A } + ) { + const n = Q(e, { configuration: r, ident: A }), + o = (function (e, t) { + switch (t) { + case u.CONFIGURATION: + return e.get('npmAlwaysAuth'); + case u.BEST_EFFORT: + case u.ALWAYS_AUTH: + return !0; + case u.NO_AUTH: + return !1; + default: + throw new Error('Unreachable'); + } + })(n, t); + if (!o) return null; + if (n.get('npmAuthToken')) return 'Bearer ' + n.get('npmAuthToken'); + if (n.get('npmAuthIdent')) return 'Basic ' + n.get('npmAuthIdent'); + if (o && t !== u.BEST_EFFORT) + throw new p.lk( + d.b.AUTHENTICATION_NOT_FOUND, + 'No authentication configured for request' + ); + return null; + } + async function K() { + if (process.env.TEST_ENV) return process.env.TEST_NPM_2FA_TOKEN || ''; + const { otp: e } = await (0, C.prompt)({ + type: 'password', + name: 'otp', + message: 'One-time password:', + required: !0, + onCancel: () => process.exit(130), + }); + return e; + } + function M(e) { + if ('HTTPError' !== e.name) return !1; + try { + return e.response.headers['www-authenticate'] + .split(/,\s*/) + .map((e) => e.toLowerCase()) + .includes('otp'); + } catch (e) { + return !1; + } + } + function R(e) { + return { 'npm-otp': e }; + } + !(function (e) { + (e.FETCH_REGISTRY = 'npmRegistryServer'), + (e.PUBLISH_REGISTRY = 'npmPublishRegistry'); + })(l || (l = {})), + (function (e) { + (e[(e.NO_AUTH = 0)] = 'NO_AUTH'), + (e[(e.BEST_EFFORT = 1)] = 'BEST_EFFORT'), + (e[(e.CONFIGURATION = 2)] = 'CONFIGURATION'), + (e[(e.ALWAYS_AUTH = 3)] = 'ALWAYS_AUTH'); + })(u || (u = {})); + class x { + supports(e, t) { + if (!e.reference.startsWith('npm:')) return !1; + const r = new f.URL(e.reference); + return ( + !!g().valid(r.pathname) && !r.searchParams.has('__archiveUrl') + ); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [A, n, o] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + s.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the remote registry" + ), + loader: () => this.fetchFromNetwork(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: A, + releaseFs: n, + prefixPath: s.getIdentVendorPath(e), + checksum: o, + }; + } + async fetchFromNetwork(e, t) { + let r; + try { + r = await v(x.getLocatorUrl(e), { + configuration: t.project.configuration, + ident: e, + }); + } catch (A) { + r = await v(x.getLocatorUrl(e).replace(/%2f/g, '/'), { + configuration: t.project.configuration, + ident: e, + }); + } + return await a.convertToZip(r, { + compressionLevel: t.project.configuration.get('compressionLevel'), + prefixPath: s.getIdentVendorPath(e), + stripComponents: 1, + }); + } + static isConventionalTarballUrl(e, t, { configuration: r }) { + let A = B(e.scope, { configuration: r }); + const n = x.getLocatorUrl(e); + return ( + (t = t.replace( + /^https?:(\/\/(?:[^/]+\.)?npmjs.org(?:$|\/))/, + 'https:$1' + )), + (A = A.replace( + /^https:\/\/registry\.npmjs\.org($|\/)/, + 'https://registry.yarnpkg.com$1' + )), + (t = t.replace( + /^https:\/\/registry\.npmjs\.org($|\/)/, + 'https://registry.yarnpkg.com$1' + )) === + A + n || t === A + n.replace(/%2f/g, '/') + ); + } + static getLocatorUrl(e) { + const t = g().clean(e.reference.slice('npm:'.length)); + if (null === t) + throw new p.lk( + d.b.RESOLVER_NOT_FOUND, + "The npm semver resolver got selected, but the version isn't semver" + ); + return `${b(e)}/-/${e.name}-${t}.tgz`; + } + } + var L = r(46611), + P = r(36545), + O = r(32485); + const U = s.makeIdent(null, 'node-gyp'), + T = /\b(node-gyp|prebuild-install)\b/; + var j = r(52779); + var Y = r(49881), + G = r(76417), + H = r(10129); + async function J(e, t, { access: r, tag: A, registry: n }) { + const o = e.project.configuration, + i = e.manifest.name, + a = e.manifest.version, + c = s.stringifyIdent(i), + g = (0, G.createHash)('sha1').update(t).digest('hex'), + l = H.Sd(t).toString(); + void 0 === r && + (r = + e.manifest.publishConfig && + 'string' == typeof e.manifest.publishConfig.access + ? e.manifest.publishConfig.access + : null !== o.get('npmPublishAccess') + ? o.get('npmPublishAccess') + : i.scope + ? 'restricted' + : 'public'); + const u = await Y.packUtils.genPackageManifest(e), + h = `${c}-${a}.tgz`, + p = new f.URL(`${c}/-/${h}`, n); + return { + _id: c, + _attachments: { + [h]: { + content_type: 'application/octet-stream', + data: t.toString('base64'), + length: t.length, + }, + }, + name: c, + access: r, + 'dist-tags': { [A]: a }, + versions: { + [a]: { + ...u, + _id: `${c}@${a}`, + name: c, + version: a, + dist: { shasum: g, integrity: l, tarball: p.toString() }, + }, + }, + }; + } + const q = { + npmAlwaysAuth: { + description: + "URL of the selected npm registry (note: npm enterprise isn't supported)", + type: i.a2.BOOLEAN, + default: !1, + }, + npmAuthIdent: { + description: + 'Authentication identity for the npm registry (_auth in npm and yarn v1)', + type: i.a2.SECRET, + default: null, + }, + npmAuthToken: { + description: + 'Authentication token for the npm registry (_authToken in npm and yarn v1)', + type: i.a2.SECRET, + default: null, + }, + }, + z = { + npmPublishRegistry: { + description: 'Registry to push packages to', + type: i.a2.STRING, + default: null, + }, + npmRegistryServer: { + description: + "URL of the selected npm registry (note: npm enterprise isn't supported)", + type: i.a2.STRING, + default: 'https://registry.yarnpkg.com', + }, + }, + W = { + configuration: { + ...q, + ...z, + npmScopes: { + description: 'Settings per package scope', + type: i.a2.MAP, + valueDefinition: { + description: '', + type: i.a2.SHAPE, + properties: { ...q, ...z }, + }, + }, + npmRegistries: { + description: 'Settings per registry', + type: i.a2.MAP, + normalizeKeys: I, + valueDefinition: { + description: '', + type: i.a2.SHAPE, + properties: { ...q }, + }, + }, + }, + fetchers: [ + class { + supports(e, t) { + if (!e.reference.startsWith('npm:')) return !1; + const { selector: r, params: A } = s.parseRange(e.reference); + return ( + !!g().valid(r) && + null !== A && + 'string' == typeof A.__archiveUrl + ); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [A, n, o] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + s.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the remote server" + ), + loader: () => this.fetchFromNetwork(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: A, + releaseFs: n, + prefixPath: s.getIdentVendorPath(e), + checksum: o, + }; + } + async fetchFromNetwork(e, t) { + const { params: r } = s.parseRange(e.reference); + if (null === r || 'string' != typeof r.__archiveUrl) + throw new Error( + 'Assertion failed: The archiveUrl querystring parameter should have been available' + ); + const A = await v(r.__archiveUrl, { + configuration: t.project.configuration, + ident: e, + }); + return await a.convertToZip(A, { + compressionLevel: t.project.configuration.get( + 'compressionLevel' + ), + prefixPath: s.getIdentVendorPath(e), + stripComponents: 1, + }); + } + }, + x, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return ( + !!e.range.startsWith('npm:') && + !!s.tryParseDescriptor(e.range.slice('npm:'.length), !0) + ); + } + supportsLocator(e, t) { + return !1; + } + shouldPersistResolution(e, t) { + throw new Error('Unreachable'); + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + const r = s.parseDescriptor(e.range.slice('npm:'.length), !0); + return t.resolver.getResolutionDependencies(r, t); + } + async getCandidates(e, t, r) { + const A = s.parseDescriptor(e.range.slice('npm:'.length), !0); + return await r.resolver.getCandidates(A, t, r); + } + async getSatisfying(e, t, r) { + const A = s.parseDescriptor(e.range.slice('npm:'.length), !0); + return r.resolver.getSatisfying(A, t, r); + } + resolve(e, t) { + throw new Error('Unreachable'); + } + }, + class { + supportsDescriptor(e, t) { + return ( + !!e.range.startsWith('npm:') && + !!P.validRange(e.range.slice('npm:'.length)) + ); + } + supportsLocator(e, t) { + if (!e.reference.startsWith('npm:')) return !1; + const { selector: r } = s.parseRange(e.reference); + return !!g().valid(r); + } + shouldPersistResolution(e, t) { + return !0; + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + const A = P.validRange(e.range.slice('npm:'.length)); + if (null === A) + throw new Error( + 'Expected a valid range, got ' + + e.range.slice('npm:'.length) + ); + const n = await v(b(e), { + configuration: r.project.configuration, + ident: e, + jsonResponse: !0, + }), + o = Object.keys(n.versions) + .map((e) => new (g().SemVer)(e)) + .filter((e) => A.test(e)), + i = o.filter((e) => !n.versions[e.raw].deprecated), + a = i.length > 0 ? i : o; + return ( + a.sort((e, t) => -e.compare(t)), + a.map((t) => { + const A = s.makeLocator(e, 'npm:' + t.raw), + o = n.versions[t.raw].dist.tarball; + return x.isConventionalTarballUrl(A, o, { + configuration: r.project.configuration, + }) + ? A + : s.bindLocator(A, { __archiveUrl: o }); + }) + ); + } + async getSatisfying(e, t, r) { + const A = P.validRange(e.range.slice('npm:'.length)); + if (null === A) + throw new Error( + 'Expected a valid range, got ' + + e.range.slice('npm:'.length) + ); + return t + .map((e) => { + try { + return new (g().SemVer)(e.slice('npm:'.length)); + } catch (e) { + return null; + } + }) + .filter((e) => null !== e) + .filter((e) => A.test(e)) + .sort((e, t) => -e.compare(t)) + .map((t) => s.makeLocator(e, 'npm:' + t.raw)); + } + async resolve(e, t) { + const { selector: r } = s.parseRange(e.reference), + A = g().clean(r); + if (null === A) + throw new p.lk( + d.b.RESOLVER_NOT_FOUND, + "The npm semver resolver got selected, but the version isn't semver" + ); + const n = await v(b(e), { + configuration: t.project.configuration, + ident: e, + jsonResponse: !0, + }); + if (!Object.prototype.hasOwnProperty.call(n, 'versions')) + throw new p.lk( + d.b.REMOTE_INVALID, + 'Registry returned invalid data for - missing "versions" field' + ); + if (!Object.prototype.hasOwnProperty.call(n.versions, A)) + throw new p.lk( + d.b.REMOTE_NOT_FOUND, + `Registry failed to return reference "${A}"` + ); + const o = new L.G(); + if ( + (o.load(n.versions[A]), + !o.dependencies.has(U.identHash) && + !o.peerDependencies.has(U.identHash)) + ) + for (const r of o.scripts.values()) + if (r.match(T)) { + o.dependencies.set( + U.identHash, + s.makeDescriptor(U, 'latest') + ), + t.report.reportWarning( + d.b.NODE_GYP_INJECTED, + s.prettyLocator(t.project.configuration, e) + + ': Implicit dependencies on node-gyp are discouraged' + ); + break; + } + return ( + 'string' == typeof o.raw.deprecated && + t.report.reportWarning( + d.b.DEPRECATED_PACKAGE, + `${s.prettyLocator( + t.project.configuration, + e + )} is deprecated: ${o.raw.deprecated}` + ), + { + ...e, + version: A, + languageName: 'node', + linkType: O.Un.HARD, + dependencies: o.dependencies, + peerDependencies: o.peerDependencies, + dependenciesMeta: o.dependenciesMeta, + peerDependenciesMeta: o.peerDependenciesMeta, + bin: o.bin, + } + ); + } + }, + class { + supportsDescriptor(e, t) { + return ( + !!e.range.startsWith('npm:') && + !!j.c.test(e.range.slice('npm:'.length)) + ); + } + supportsLocator(e, t) { + return !1; + } + shouldPersistResolution(e, t) { + throw new Error('Unreachable'); + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + const A = e.range.slice('npm:'.length), + n = await v(b(e), { + configuration: r.project.configuration, + ident: e, + jsonResponse: !0, + }); + if (!Object.prototype.hasOwnProperty.call(n, 'dist-tags')) + throw new p.lk( + d.b.REMOTE_INVALID, + 'Registry returned invalid data - missing "dist-tags" field' + ); + const o = n['dist-tags']; + if (!Object.prototype.hasOwnProperty.call(o, A)) + throw new p.lk( + d.b.REMOTE_NOT_FOUND, + `Registry failed to return tag "${A}"` + ); + const i = o[A], + a = s.makeLocator(e, 'npm:' + i), + c = n.versions[i].dist.tarball; + return x.isConventionalTarballUrl(a, c, { + configuration: r.project.configuration, + }) + ? [a] + : [s.bindLocator(a, { __archiveUrl: c })]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + throw new Error('Unreachable'); + } + }, + ], + }; + }, + 49881: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => T, packUtils: () => A }); + var A = {}; + r.r(A), + r.d(A, { + genPackList: () => K, + genPackStream: () => N, + genPackageManifest: () => F, + hasPackScripts: () => S, + prepareForPack: () => k, + }); + var n = r(54143), + o = r(35691), + i = r(92659), + s = r(36370), + a = r(40822); + class c extends a.Command {} + (0, s.gn)( + [a.Command.String('--cwd', { hidden: !0 })], + c.prototype, + 'cwd', + void 0 + ); + var g = r(46611), + l = r(46009); + class u extends a.UsageError { + constructor(e, t) { + super( + `This command can only be run from within a workspace of your project (${l.y1.relative( + e, + t + )} isn't a workspace of ${l.y1.join(e, g.G.fileName)}).` + ); + } + } + r(63129), r(5864), r(35747); + new Map([ + [ + 'constraints', + [ + ['constraints', 'query'], + ['constraints', 'source'], + ['constraints'], + ], + ], + ['exec', []], + ['interactive-tools', [['search'], ['upgrade-interactive']]], + ['stage', [['stage']]], + ['typescript', []], + [ + 'version', + [['version', 'apply'], ['version', 'check'], ['version']], + ], + [ + 'workspace-tools', + [ + ['workspaces', 'focus'], + ['workspaces', 'foreach'], + ], + ], + ]); + var h = r(71643), + p = r(39922); + (0, s.gn)( + [a.Command.Path('--welcome')], + class extends c { + async execute() { + const e = await p.VK.find(this.context.cwd, this.context.plugins); + this.context.stdout.write( + ((e) => + `\n${h.pretty( + e, + 'Welcome on Yarn 2!', + 'bold' + )} 🎉 Thanks for helping us shape our vision of how projects\nshould be managed going forward.\n\nBeing still in RC, Yarn 2 isn't completely stable yet. Some features might be\nmissing, and some behaviors may have received major overhaul. In case of doubt,\nuse the following URLs to get some insight:\n\n - The changelog:\n ${h.pretty( + e, + 'https://github.com/yarnpkg/berry/tree/CHANGELOG.md', + 'cyan' + )}\n\n - Our issue tracker:\n ${h.pretty( + e, + 'https://github.com/yarnpkg/berry', + 'cyan' + )}\n\n - Our Discord server:\n ${h.pretty( + e, + 'https://discord.gg/yarnpkg', + 'cyan' + )}\n\nWe're hoping you will enjoy the experience. For now, a good start is to run\nthe two following commands:\n\n ${h.pretty( + e, + 'find . -name node_modules -prune -exec rm -r {} \\;', + 'magenta' + )}\n ${h.pretty( + e, + 'yarn install', + 'magenta' + )}\n\nOne last trick! If you need at some point to upgrade Yarn to a nightly build,\nthe following command will install the CLI straight from master:\n\n ${h.pretty( + e, + 'yarn set version from sources', + 'magenta' + )}\n\nSee you later 👋\n`)(e).trim() + '\n' + ); + } + }.prototype, + 'execute', + null + ); + var d = r(85824), + C = r(28148), + f = r(33720), + I = r(15815), + E = r(43896), + B = r(63088), + y = r(10489), + m = r(2401), + w = r.n(m), + Q = r(59938), + D = r(78761); + const b = [ + '/package.json', + '/readme', + '/readme.*', + '/license', + '/license.*', + '/licence', + '/licence.*', + '/changelog', + '/changelog.*', + ], + v = [ + '/package.tgz', + '.github', + '.git', + '.hg', + 'node_modules', + '.npmignore', + '.gitignore', + '.#*', + '.DS_Store', + ]; + async function S(e) { + return ( + !!B.hasWorkspaceScript(e, 'prepack') || + !!B.hasWorkspaceScript(e, 'postpack') + ); + } + async function k(e, { report: t }, r) { + await B.maybeExecuteWorkspaceLifecycleScript(e, 'prepack', { + report: t, + }); + try { + await r(); + } finally { + await B.maybeExecuteWorkspaceLifecycleScript(e, 'postpack', { + report: t, + }); + } + } + async function N(e, t) { + var r, A; + void 0 === t && (t = await K(e)); + const n = new Set(); + for (const t of null !== + (A = + null === (r = e.manifest.publishConfig) || void 0 === r + ? void 0 + : r.executableFiles) && void 0 !== A + ? A + : new Set()) + n.add(l.y1.normalize(t)); + for (const t of e.manifest.bin.values()) n.add(l.y1.normalize(t)); + const o = Q.pack(); + process.nextTick(async () => { + for (const r of t) { + const t = l.y1.normalize(r), + A = l.y1.resolve(e.cwd, t), + i = l.y1.join('package', t), + s = await E.xfs.lstatPromise(A), + a = { name: i, mtime: new Date(3155328e5) }, + c = n.has(t) ? 493 : 420; + let g, u; + const h = new Promise((e, t) => { + (g = e), (u = t); + }), + p = (e) => { + e ? u(e) : g(); + }; + if (s.isFile()) { + let r; + (r = + 'package.json' === t + ? Buffer.from(JSON.stringify(await F(e), null, 2)) + : await E.xfs.readFilePromise(A)), + o.entry({ ...a, mode: c, type: 'file' }, r, p); + } else + s.isSymbolicLink() + ? o.entry( + { + ...a, + mode: c, + type: 'symlink', + linkname: await E.xfs.readlinkPromise(A), + }, + p + ) + : p( + new Error( + `Unsupported file type ${ + s.mode + } for ${l.cS.fromPortablePath(t)}` + ) + ); + await h; + } + o.finalize(); + }); + const i = (0, D.createGzip)(); + return o.pipe(i), i; + } + async function F(e) { + const t = JSON.parse(JSON.stringify(e.manifest.raw)); + return ( + await e.project.configuration.triggerHook( + (e) => e.beforeWorkspacePacking, + e, + t + ), + t + ); + } + async function K(e) { + var t, r, A, n, o, i, s, a; + const c = e.project, + g = c.configuration, + u = { accept: [], reject: [] }; + for (const e of v) u.reject.push(e); + for (const e of b) u.accept.push(e); + u.reject.push(g.get('rcFilename')); + const h = (t) => { + if (null === t || !t.startsWith(e.cwd + '/')) return; + const r = l.y1.relative(e.cwd, t), + A = l.y1.resolve(l.LZ.root, r); + u.reject.push(A); + }; + h(l.y1.resolve(c.cwd, g.get('lockfileFilename'))), + h(g.get('bstatePath')), + h(g.get('cacheFolder')), + h(g.get('globalFolder')), + h(g.get('installStatePath')), + h(g.get('virtualFolder')), + h(g.get('yarnPath')), + await g.triggerHook( + (e) => e.populateYarnPaths, + c, + (e) => { + h(e); + } + ); + for (const t of c.workspaces) { + const r = l.y1.relative(e.cwd, t.cwd); + '' === r || r.match(/^(\.\.)?\//) || u.reject.push('/' + r); + } + const p = { accept: [], reject: [] }, + d = + null !== + (r = + null === (t = e.manifest.publishConfig) || void 0 === t + ? void 0 + : t.main) && void 0 !== r + ? r + : e.manifest.main, + C = + null !== + (n = + null === (A = e.manifest.publishConfig) || void 0 === A + ? void 0 + : A.module) && void 0 !== n + ? n + : e.manifest.module, + f = + null !== + (i = + null === (o = e.manifest.publishConfig) || void 0 === o + ? void 0 + : o.browser) && void 0 !== i + ? i + : e.manifest.browser, + I = + null !== + (a = + null === (s = e.manifest.publishConfig) || void 0 === s + ? void 0 + : s.bin) && void 0 !== a + ? a + : e.manifest.bin; + null != d && p.accept.push(l.y1.resolve(l.LZ.root, d)), + null != C && p.accept.push(l.y1.resolve(l.LZ.root, C)), + 'string' == typeof f && p.accept.push(l.y1.resolve(l.LZ.root, f)); + for (const e of I.values()) p.accept.push(l.y1.resolve(l.LZ.root, e)); + if (f instanceof Map) + for (const [e, t] of f.entries()) + p.accept.push(l.y1.resolve(l.LZ.root, e)), + 'string' == typeof t && + p.accept.push(l.y1.resolve(l.LZ.root, t)); + const E = null !== e.manifest.files; + if (E) { + p.reject.push('/*'); + for (const t of e.manifest.files) + R(p.accept, t, { cwd: l.LZ.root }); + } + return await (async function ( + e, + { hasExplicitFileList: t, globalList: r, ignoreList: A } + ) { + const n = [], + o = new y.n(e), + i = [[l.LZ.root, [A]]]; + for (; i.length > 0; ) { + const [e, A] = i.pop(), + s = await o.lstatPromise(e); + if ( + !x(e, { + globalList: r, + ignoreLists: s.isDirectory() ? null : A, + }) + ) + if (s.isDirectory()) { + const n = await o.readdirPromise(e); + let s = !1, + a = !1; + if (!t || e !== l.LZ.root) + for (const e of n) + (s = s || '.gitignore' === e), + (a = a || '.npmignore' === e); + const c = a + ? await M(o, e, '.npmignore') + : s + ? await M(o, e, '.gitignore') + : null; + let g = null !== c ? [c].concat(A) : A; + x(e, { globalList: r, ignoreLists: A }) && + (g = [...A, { accept: [], reject: ['**/*'] }]); + for (const t of n) i.push([l.y1.resolve(e, t), g]); + } else + (s.isFile() || s.isSymbolicLink()) && + n.push(l.y1.relative(l.LZ.root, e)); + } + return n.sort(); + })(e.cwd, { hasExplicitFileList: E, globalList: u, ignoreList: p }); + } + async function M(e, t, r) { + const A = { accept: [], reject: [] }, + n = await e.readFilePromise(l.y1.join(t, r), 'utf8'); + for (const e of n.split(/\n/g)) R(A.reject, e, { cwd: t }); + return A; + } + function R(e, t, { cwd: r }) { + const A = t.trim(); + '' !== A && + '#' !== A[0] && + e.push( + (function (e, { cwd: t }) { + const r = '!' === e[0]; + return ( + r && (e = e.slice(1)), + e.match(/\.{0,1}\//) && (e = l.y1.resolve(t, e)), + r && (e = '!' + e), + e + ); + })(A, { cwd: r }) + ); + } + function x(e, { globalList: t, ignoreLists: r }) { + if (L(e, t.accept)) return !1; + if (L(e, t.reject)) return !0; + if (null !== r) + for (const t of r) { + if (L(e, t.accept)) return !1; + if (L(e, t.reject)) return !0; + } + return !1; + } + function L(e, t) { + let r = t; + const A = []; + for (let e = 0; e < t.length; ++e) + '!' !== t[e][0] + ? r !== t && r.push(t[e]) + : (r === t && (r = t.slice(0, e)), A.push(t[e].slice(1))); + return !P(e, A) && !!P(e, r); + } + function P(e, t) { + let r = t; + const A = []; + for (let e = 0; e < t.length; ++e) + t[e].includes('/') + ? r !== t && r.push(t[e]) + : (r === t && (r = t.slice(0, e)), A.push(t[e])); + return ( + !!w().isMatch(e, r, { dot: !0, nocase: !0 }) || + !!w().isMatch(e, A, { dot: !0, basename: !0, nocase: !0 }) + ); + } + class O extends c { + constructor() { + super(...arguments), + (this.installIfNeeded = !1), + (this.dryRun = !1), + (this.json = !1); + } + async execute() { + const e = await p.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await d.I.find( + e, + this.context.cwd + ); + if (!r) throw new u(t.cwd, this.context.cwd); + (await S(r)) && + (this.installIfNeeded + ? await t.install({ + cache: await C.C.find(e), + report: new f.$(), + }) + : await t.restoreInstallState()); + const A = + void 0 !== this.out + ? l.y1.resolve( + this.context.cwd, + (function (e, { workspace: t }) { + const r = e + .replace( + '%s', + (function (e) { + return null !== e.manifest.name + ? n.slugifyIdent(e.manifest.name) + : 'package'; + })(t) + ) + .replace( + '%v', + (function (e) { + return null !== e.manifest.version + ? e.manifest.version + : 'unknown'; + })(t) + ); + return l.cS.toPortablePath(r); + })(this.out, { workspace: r }) + ) + : l.y1.resolve(r.cwd, 'package.tgz'); + return ( + await I.Pk.start( + { + configuration: e, + stdout: this.context.stdout, + json: this.json, + }, + async (t) => { + await k(r, { report: t }, async () => { + t.reportJson({ base: r.cwd }); + const e = await K(r); + for (const r of e) + t.reportInfo(null, r), t.reportJson({ location: r }); + if (!this.dryRun) { + const t = await N(r, e), + n = E.xfs.createWriteStream(A); + t.pipe(n), + await new Promise((e) => { + n.on('finish', e); + }); + } + }), + this.dryRun || + (t.reportInfo( + i.b.UNNAMED, + 'Package archive generated in ' + + h.pretty(e, A, h.Type.PATH) + ), + t.reportJson({ output: A })); + } + ) + ).exitCode(); + } + } + (O.usage = a.Command.Usage({ + description: 'generate a tarball from the active workspace', + details: + '\n This command will turn the active workspace into a compressed archive suitable for publishing. The archive will by default be stored at the root of the workspace (`package.tgz`).\n\n If the `-o,---out` is set the archive will be created at the specified path. The `%s` and `%v` variables can be used within the path and will be respectively replaced by the package name and version.\n ', + examples: [ + ['Create an archive from the active workspace', 'yarn pack'], + [ + "List the files that would be made part of the workspace's archive", + 'yarn pack --dry-run', + ], + [ + 'Name and output the archive in a dedicated folder', + 'yarn pack --out /artifacts/%s-%v.tgz', + ], + ], + })), + (0, s.gn)( + [ + a.Command.Boolean('--install-if-needed', { + description: + 'Run a preliminary `yarn install` if the package contains build scripts', + }), + ], + O.prototype, + 'installIfNeeded', + void 0 + ), + (0, s.gn)( + [ + a.Command.Boolean('-n,--dry-run', { + description: + 'Print the file paths without actually generating the package archive', + }), + ], + O.prototype, + 'dryRun', + void 0 + ), + (0, s.gn)( + [ + a.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + O.prototype, + 'json', + void 0 + ), + (0, s.gn)( + [ + a.Command.String('--filename', { + hidden: !1, + description: 'Create the archive at the specified path', + }), + a.Command.String('-o,--out', { + description: 'Create the archive at the specified path', + }), + ], + O.prototype, + 'out', + void 0 + ), + (0, s.gn)([a.Command.Path('pack')], O.prototype, 'execute', null); + const U = ['dependencies', 'devDependencies', 'peerDependencies'], + T = { + hooks: { + beforeWorkspacePacking: (e, t) => { + t.publishConfig && + (t.publishConfig.main && (t.main = t.publishConfig.main), + t.publishConfig.browser && + (t.browser = t.publishConfig.browser), + t.publishConfig.module && (t.module = t.publishConfig.module), + t.publishConfig.browser && + (t.browser = t.publishConfig.browser), + t.publishConfig.bin && (t.bin = t.publishConfig.bin)); + const r = e.project; + for (const A of U) + for (const s of e.manifest.getForScope(A).values()) { + const e = r.tryWorkspaceByDescriptor(s), + a = n.parseRange(s.range); + if ('workspace:' === a.protocol) + if (null === e) { + if (null === r.tryWorkspaceByIdent(s)) + throw new o.lk( + i.b.WORKSPACE_NOT_FOUND, + n.prettyDescriptor(r.configuration, s) + + ': No local workspace found for this range' + ); + } else { + let r; + (r = + n.areDescriptorsEqual(s, e.anchoredDescriptor) || + '*' === a.selector + ? e.manifest.version + : a.selector), + (t[A][n.stringifyIdent(s)] = r); + } + } + }, + }, + commands: [O], + }; + }, + 29936: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { default: () => re, patchUtils: () => A }); + var A = {}; + r.r(A), + r.d(A, { + applyPatchFile: () => S, + diffFolders: () => H, + extractPackageToDisk: () => G, + isParentRequired: () => j, + loadPatchFiles: () => Y, + makeDescriptor: () => O, + makeLocator: () => U, + parseDescriptor: () => x, + parseLocator: () => L, + parsePatchFile: () => D, + }); + var n = r(39922), + o = r(35691), + i = r(92659), + s = r(54143), + a = r(73632), + c = r(43896), + g = r(46009), + l = r(90739), + u = r(75448), + h = r(65281), + p = r(33720), + d = r(6220), + C = r(36545), + f = r(78420); + class I extends Error { + constructor(e, t) { + super('Cannot apply hunk #' + (e + 1)), (this.hunk = t); + } + } + const E = /^@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@.*/; + function B(e) { + return g.y1.relative( + g.LZ.root, + g.y1.resolve(g.LZ.root, g.cS.toPortablePath(e)) + ); + } + function y(e) { + const t = e.trim().match(E); + if (!t) throw new Error(`Bad header line: '${e}'`); + return { + original: { + start: Math.max(Number(t[1]), 1), + length: Number(t[3] || 1), + }, + patched: { + start: Math.max(Number(t[4]), 1), + length: Number(t[6] || 1), + }, + }; + } + var m; + !(function (e) { + (e.Context = 'context'), + (e.Insertion = 'insertion'), + (e.Deletion = 'deletion'); + })(m || (m = {})); + const w = { + '@': 'header', + '-': m.Deletion, + '+': m.Insertion, + ' ': m.Context, + '\\': 'pragma', + undefined: m.Context, + }; + function Q(e) { + const t = 511 & parseInt(e, 8); + if (420 !== t && 493 !== t) + throw new Error('Unexpected file mode string: ' + e); + return t; + } + function D(e) { + const t = e.split(/\n/g); + return ( + '' === t[t.length - 1] && t.pop(), + (function (e) { + const t = []; + for (const r of e) { + const { + semverExclusivity: e, + diffLineFromPath: A, + diffLineToPath: n, + oldMode: o, + newMode: i, + deletedFileMode: s, + newFileMode: c, + renameFrom: g, + renameTo: l, + beforeHash: u, + afterHash: h, + fromPath: p, + toPath: d, + hunks: C, + } = r, + f = g + ? 'rename' + : s + ? 'file deletion' + : c + ? 'file creation' + : C && C.length > 0 + ? 'patch' + : 'mode change'; + let I = null; + switch (f) { + case 'rename': + if (!g || !l) + throw new Error( + 'Bad parser state: rename from & to not given' + ); + t.push({ + type: 'rename', + semverExclusivity: e, + fromPath: B(g), + toPath: B(l), + }), + (I = l); + break; + case 'file deletion': + { + const r = A || p; + if (!r) + throw new Error( + 'Bad parse state: no path given for file deletion' + ); + t.push({ + type: 'file deletion', + semverExclusivity: e, + hunk: (C && C[0]) || null, + path: B(r), + mode: Q(s), + hash: u, + }); + } + break; + case 'file creation': + { + const r = n || d; + if (!r) + throw new Error( + 'Bad parse state: no path given for file creation' + ); + t.push({ + type: 'file creation', + semverExclusivity: e, + hunk: (C && C[0]) || null, + path: B(r), + mode: Q(c), + hash: h, + }); + } + break; + case 'patch': + case 'mode change': + I = d || n; + break; + default: + a.assertNever(f); + } + I && + o && + i && + o !== i && + t.push({ + type: 'mode change', + semverExclusivity: e, + path: B(I), + oldMode: Q(o), + newMode: Q(i), + }), + I && + C && + C.length && + t.push({ + type: 'patch', + semverExclusivity: e, + path: B(I), + hunks: C, + beforeHash: u, + afterHash: h, + }); + } + return t; + })( + (function (e) { + const t = []; + let r = { + semverExclusivity: null, + diffLineFromPath: null, + diffLineToPath: null, + oldMode: null, + newMode: null, + deletedFileMode: null, + newFileMode: null, + renameFrom: null, + renameTo: null, + beforeHash: null, + afterHash: null, + fromPath: null, + toPath: null, + hunks: null, + }, + A = 'parsing header', + n = null, + o = null; + function i() { + n && + (o && (n.parts.push(o), (o = null)), + r.hunks.push(n), + (n = null)); + } + function s() { + i(), + t.push(r), + (r = { + semverExclusivity: null, + diffLineFromPath: null, + diffLineToPath: null, + oldMode: null, + newMode: null, + deletedFileMode: null, + newFileMode: null, + renameFrom: null, + renameTo: null, + beforeHash: null, + afterHash: null, + fromPath: null, + toPath: null, + hunks: null, + }); + } + for (let t = 0; t < e.length; t++) { + const c = e[t]; + if ('parsing header' === A) + if (c.startsWith('@@')) + (A = 'parsing hunks'), (r.hunks = []), (t -= 1); + else if (c.startsWith('diff --git ')) { + r && r.diffLineFromPath && s(); + const e = c.match(/^diff --git a\/(.*?) b\/(.*?)\s*$/); + if (!e) throw new Error('Bad diff line: ' + c); + (r.diffLineFromPath = e[1]), (r.diffLineToPath = e[2]); + } else if (c.startsWith('old mode ')) + r.oldMode = c.slice('old mode '.length).trim(); + else if (c.startsWith('new mode ')) + r.newMode = c.slice('new mode '.length).trim(); + else if (c.startsWith('deleted file mode ')) + r.deletedFileMode = c + .slice('deleted file mode '.length) + .trim(); + else if (c.startsWith('new file mode ')) + r.newFileMode = c.slice('new file mode '.length).trim(); + else if (c.startsWith('rename from ')) + r.renameFrom = c.slice('rename from '.length).trim(); + else if (c.startsWith('rename to ')) + r.renameTo = c.slice('rename to '.length).trim(); + else if (c.startsWith('index ')) { + const e = c.match(/(\w+)\.\.(\w+)/); + if (!e) continue; + (r.beforeHash = e[1]), (r.afterHash = e[2]); + } else + c.startsWith('semver exclusivity ') + ? (r.semverExclusivity = c + .slice('semver exclusivity '.length) + .trim()) + : c.startsWith('--- ') + ? (r.fromPath = c.slice('--- a/'.length).trim()) + : c.startsWith('+++ ') && + (r.toPath = c.slice('+++ b/'.length).trim()); + else { + const e = w[c[0]] || null; + switch (e) { + case 'header': + i(), (n = { header: y(c), parts: [] }); + break; + case null: + (A = 'parsing header'), s(), (t -= 1); + break; + case 'pragma': + if (!c.startsWith('\\ No newline at end of file')) + throw new Error( + 'Unrecognized pragma in patch file: ' + c + ); + if (!o) + throw new Error( + 'Bad parser state: No newline at EOF pragma encountered without context' + ); + o.noNewlineAtEndOfFile = !0; + break; + case m.Context: + case m.Deletion: + case m.Insertion: + if (!n) + throw new Error( + 'Bad parser state: Hunk lines encountered before hunk header' + ); + o && o.type !== e && (n.parts.push(o), (o = null)), + o || + (o = { + type: e, + lines: [], + noNewlineAtEndOfFile: !1, + }), + o.lines.push(c.slice(1)); + break; + default: + a.assertNever(e); + } + } + } + s(); + for (const { hunks: e } of t) if (e) for (const t of e) b(t); + return t; + })(t) + ) + ); + } + function b(e) { + let t = 0, + r = 0; + for (const { type: A, lines: n } of e.parts) + switch (A) { + case m.Context: + (r += n.length), (t += n.length); + break; + case m.Deletion: + t += n.length; + break; + case m.Insertion: + r += n.length; + break; + default: + a.assertNever(A); + } + if (t !== e.header.original.length || r !== e.header.patched.length) { + const A = (e) => (e < 0 ? e : '+' + e); + throw new Error( + `hunk header integrity check failed (expected @@ ${A( + e.header.original.length + )} ${A(e.header.patched.length)} @@, got @@ ${A(t)} ${A(r)} @@)` + ); + } + } + async function v(e, t, r) { + const A = await e.lstatPromise(t), + n = await r(); + if ((void 0 !== n && (t = n), e.lutimesPromise)) + await e.lutimesPromise(t, A.atime, A.mtime); + else { + if (A.isSymbolicLink()) + throw new Error('Cannot preserve the time values of a symlink'); + await e.utimesPromise(t, A.atime, A.mtime); + } + } + async function S( + e, + { baseFs: t = new f.S(), dryRun: r = !1, version: A = null } = {} + ) { + for (const n of e) + if ( + null === n.semverExclusivity || + null === A || + C.satisfiesWithPrereleases(A, n.semverExclusivity) + ) + switch (n.type) { + case 'file deletion': + if (r) { + if (!t.existsSync(n.path)) + throw new Error( + "Trying to delete a file that doesn't exist: " + n.path + ); + } else + await v(t, g.y1.dirname(n.path), async () => { + await t.unlinkPromise(n.path); + }); + break; + case 'rename': + if (r) { + if (!t.existsSync(n.fromPath)) + throw new Error( + "Trying to move a file that doesn't exist: " + + n.fromPath + ); + } else + await v(t, g.y1.dirname(n.fromPath), async () => { + await v(t, g.y1.dirname(n.toPath), async () => { + await v( + t, + n.fromPath, + async () => ( + await t.movePromise(n.fromPath, n.toPath), n.toPath + ) + ); + }); + }); + break; + case 'file creation': + if (r) { + if (t.existsSync(n.path)) + throw new Error( + 'Trying to create a file that already exists: ' + n.path + ); + } else { + const e = n.hunk + ? n.hunk.parts[0].lines.join('\n') + + (n.hunk.parts[0].noNewlineAtEndOfFile ? '' : '\n') + : ''; + await t.mkdirpPromise(g.y1.dirname(n.path), { + chmod: 493, + utimes: [315532800, 315532800], + }), + await t.writeFilePromise(n.path, e, { mode: n.mode }), + await t.utimesPromise(n.path, 315532800, 315532800); + } + break; + case 'patch': + await v(t, n.path, async () => { + await F(n, { baseFs: t, dryRun: r }); + }); + break; + case 'mode change': + { + const e = (await t.statPromise(n.path)).mode; + if (k(n.newMode) !== k(e)) continue; + await v(t, n.path, async () => { + await t.chmodPromise(n.path, n.newMode); + }); + } + break; + default: + a.assertNever(n); + } + } + function k(e) { + return (64 & e) > 0; + } + function N(e) { + return e.replace(/\s+$/, ''); + } + async function F({ hunks: e, path: t }, { baseFs: r, dryRun: A = !1 }) { + const n = await r.statSync(t).mode, + o = (await r.readFileSync(t, 'utf8')).split(/\n/), + i = []; + let s = 0, + c = 0; + for (const t of e) { + const r = Math.max(c, t.header.patched.start + s), + A = Math.max(0, r - c), + n = Math.max(0, o.length - r - t.header.original.length), + a = Math.max(A, n); + let g = 0, + l = 0, + u = null; + for (; g <= a; ) { + if (g <= A && ((l = r - g), (u = K(t, o, l)), null !== u)) { + g = -g; + break; + } + if (g <= n && ((l = r + g), (u = K(t, o, l)), null !== u)) break; + g += 1; + } + if (null === u) throw new I(e.indexOf(t), t); + i.push(u), (s += g), (c = l + t.header.original.length); + } + if (A) return; + let g = 0; + for (const e of i) + for (const t of e) + switch (t.type) { + case 'splice': + { + const e = t.index + g; + o.splice(e, t.numToDelete, ...t.linesToInsert), + (g += t.linesToInsert.length - t.numToDelete); + } + break; + case 'pop': + o.pop(); + break; + case 'push': + o.push(t.line); + break; + default: + a.assertNever(t); + } + await r.writeFilePromise(t, o.join('\n'), { mode: n }); + } + function K(e, t, r) { + const A = []; + for (const o of e.parts) + switch (o.type) { + case m.Context: + case m.Deletion: + for (const e of o.lines) { + const A = t[r]; + if (null == A || ((n = e), N(A) !== N(n))) return null; + r += 1; + } + o.type === m.Deletion && + (A.push({ + type: 'splice', + index: r - o.lines.length, + numToDelete: o.lines.length, + linesToInsert: [], + }), + o.noNewlineAtEndOfFile && A.push({ type: 'push', line: '' })); + break; + case m.Insertion: + A.push({ + type: 'splice', + index: r, + numToDelete: 0, + linesToInsert: o.lines, + }), + o.noNewlineAtEndOfFile && A.push({ type: 'pop' }); + break; + default: + a.assertNever(o.type); + } + var n; + return A; + } + const M = /^builtin<([^>]+)>$/; + function R(e, t) { + const { source: r, selector: A, params: n } = s.parseRange(e); + if (null === r) + throw new Error( + 'Patch locators must explicitly define their source' + ); + const o = A ? A.split(/&/).map((e) => g.cS.toPortablePath(e)) : [], + i = + n && 'string' == typeof n.locator + ? s.parseLocator(n.locator) + : null, + a = n && 'string' == typeof n.version ? n.version : null; + return { + parentLocator: i, + sourceItem: t(r), + patchPaths: o, + sourceVersion: a, + }; + } + function x(e) { + const { sourceItem: t, ...r } = R(e.range, s.parseDescriptor); + return { ...r, sourceDescriptor: t }; + } + function L(e) { + const { sourceItem: t, ...r } = R(e.reference, s.parseLocator); + return { ...r, sourceLocator: t }; + } + function P( + { + parentLocator: e, + sourceItem: t, + patchPaths: r, + sourceVersion: A, + patchHash: n, + }, + o + ) { + const i = null !== e ? { locator: s.stringifyLocator(e) } : {}, + a = void 0 !== A ? { version: A } : {}, + c = void 0 !== n ? { hash: n } : {}; + return s.makeRange({ + protocol: 'patch:', + source: o(t), + selector: r.join('&'), + params: { ...a, ...c, ...i }, + }); + } + function O( + e, + { parentLocator: t, sourceDescriptor: r, patchPaths: A } + ) { + return s.makeLocator( + e, + P( + { parentLocator: t, sourceItem: r, patchPaths: A }, + s.stringifyDescriptor + ) + ); + } + function U( + e, + { parentLocator: t, sourcePackage: r, patchPaths: A, patchHash: n } + ) { + return s.makeLocator( + e, + P( + { + parentLocator: t, + sourceItem: r, + sourceVersion: r.version, + patchPaths: A, + patchHash: n, + }, + s.stringifyLocator + ) + ); + } + function T({ onAbsolute: e, onRelative: t, onBuiltin: r }, A) { + const n = A.match(M); + return null !== n ? r(n[1]) : g.y1.isAbsolute(A) ? e(A) : t(A); + } + function j(e) { + return T( + { onAbsolute: () => !1, onRelative: () => !0, onBuiltin: () => !1 }, + e + ); + } + async function Y(e, t, r) { + const A = null !== e ? await r.fetcher.fetch(e, r) : null, + n = + A && A.localPath + ? { + packageFs: new u.M(g.LZ.root), + prefixPath: g.y1.relative(g.LZ.root, A.localPath), + } + : A; + A && A !== n && A.releaseFs && A.releaseFs(); + return ( + await a.releaseAfterUseAsync( + async () => + await Promise.all( + t.map(async (e) => + T( + { + onAbsolute: async () => + await c.xfs.readFilePromise(e, 'utf8'), + onRelative: async () => { + if (null === A) + throw new Error( + 'Assertion failed: The parent locator should have been fetched' + ); + return await A.packageFs.readFilePromise(e, 'utf8'); + }, + onBuiltin: async (e) => + await r.project.configuration.firstHook( + (e) => e.getBuiltinPatch, + r.project, + e + ), + }, + e + ) + ) + ) + ) + ).map((e) => ('string' == typeof e ? e.replace(/\r\n?/g, '\n') : e)); + } + async function G(e, { cache: t, project: r }) { + const A = r.storedChecksums, + n = new p.$(), + o = r.configuration.makeFetcher(), + i = await o.fetch(e, { + cache: t, + project: r, + fetcher: o, + checksums: A, + report: n, + }), + a = await c.xfs.mktempPromise(); + return ( + await c.xfs.copyPromise(a, i.prefixPath, { baseFs: i.packageFs }), + await c.xfs.writeJsonPromise(g.y1.join(a, '.yarn-patch.json'), { + locator: s.stringifyLocator(e), + }), + c.xfs.detachTemp(a), + a + ); + } + async function H(e, t) { + const r = g.cS.fromPortablePath(e).replace(/\\/g, '/'), + A = g.cS.fromPortablePath(t).replace(/\\/g, '/'), + { stdout: n } = await d.execvp( + 'git', + [ + 'diff', + '--src-prefix=a/', + '--dst-prefix=b/', + '--ignore-cr-at-eol', + '--full-index', + '--no-index', + r, + A, + ], + { cwd: g.cS.toPortablePath(process.cwd()) } + ), + o = r.startsWith('/') ? (e) => e.slice(1) : (e) => e; + return n + .replace( + new RegExp(`(a|b)(${a.escapeRegExp(`/${o(r)}/`)})`, 'g'), + '$1/' + ) + .replace( + new RegExp('(a|b)' + a.escapeRegExp(`/${o(A)}/`), 'g'), + '$1/' + ) + .replace(new RegExp(a.escapeRegExp(r + '/'), 'g'), '') + .replace(new RegExp(a.escapeRegExp(A + '/'), 'g'), ''); + } + var J = r(71643); + function q(e, { configuration: t, report: r }) { + for (const A of e.parts) + for (const e of A.lines) + switch (A.type) { + case m.Context: + r.reportInfo(null, ' ' + J.pretty(t, e, 'grey')); + break; + case m.Deletion: + r.reportError( + i.b.FROZEN_LOCKFILE_EXCEPTION, + '- ' + J.pretty(t, e, J.Type.REMOVED) + ); + break; + case m.Insertion: + r.reportError( + i.b.FROZEN_LOCKFILE_EXCEPTION, + '+ ' + J.pretty(t, e, J.Type.ADDED) + ); + break; + default: + a.assertNever(A.type); + } + } + var z = r(20624); + var W = r(36370), + V = r(25413), + X = r(85824), + _ = r(28148), + Z = r(40822); + class $ extends V.BaseCommand { + async execute() { + const e = await n.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await X.I.find( + e, + this.context.cwd + ), + A = await _.C.find(e); + if (!r) throw new V.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState(); + const o = g.y1.resolve( + this.context.cwd, + g.cS.toPortablePath(this.patchFolder) + ), + i = g.y1.join(o, '.yarn-patch.json'); + if (!c.xfs.existsSync(i)) + throw new Z.UsageError( + "The argument folder didn't get created by 'yarn patch'" + ); + const a = await c.xfs.readJsonPromise(i), + l = s.parseLocator(a.locator, !0); + if (!t.storedPackages.has(l.locatorHash)) + throw new Z.UsageError( + 'No package found in the project for the given locator' + ); + const u = await G(l, { cache: A, project: t }); + this.context.stdout.write(await H(u, o)); + } + } + ($.usage = Z.Command.Usage({ + description: + '\n This will turn the folder passed in parameter into a patchfile suitable for consumption with the `patch:` protocol.\n\n Only folders generated through `yarn patch` are accepted as valid input for `yarn patch-commit`.\n ', + })), + (0, W.gn)([Z.Command.String()], $.prototype, 'patchFolder', void 0), + (0, W.gn)( + [Z.Command.Path('patch-commit')], + $.prototype, + 'execute', + null + ); + var ee = r(15815); + class te extends V.BaseCommand { + async execute() { + const e = await n.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await X.I.find( + e, + this.context.cwd + ), + A = await _.C.find(e); + if (!r) throw new V.WorkspaceRequiredError(t.cwd, this.context.cwd); + await t.restoreInstallState(); + let o = s.parseLocator(this.package); + if ('unknown' === o.reference) { + const r = a.mapAndFilter([...t.storedPackages.values()], (e) => + e.identHash !== o.identHash || s.isVirtualLocator(e) + ? a.mapAndFilter.skip + : e + ); + if (0 === r.length) + throw new Z.UsageError( + 'No package found in the project for the given locator' + ); + if (r.length > 1) + throw new Z.UsageError( + 'Multiple candidate packages found; explicitly choose one of them (use `yarn why ` to get more information as to who depends on them):\n' + + r.map((t) => '\n- ' + s.prettyLocator(e, t)).join('') + ); + o = r[0]; + } + if (!t.storedPackages.has(o.locatorHash)) + throw new Z.UsageError( + 'No package found in the project for the given locator' + ); + await ee.Pk.start( + { configuration: e, stdout: this.context.stdout }, + async (r) => { + const n = await G(o, { cache: A, project: t }); + r.reportInfo( + i.b.UNNAMED, + `Package ${s.prettyLocator(e, o)} got extracted with success!` + ), + r.reportInfo( + i.b.UNNAMED, + 'You can now edit the following folder: ' + + J.pretty(e, g.cS.fromPortablePath(n), 'magenta') + ), + r.reportInfo( + i.b.UNNAMED, + `Once you are done run ${J.pretty( + e, + 'yarn patch-commit ' + g.cS.fromPortablePath(n), + 'cyan' + )} and Yarn will store a patchfile based on your changes.` + ); + } + ); + } + } + (te.usage = Z.Command.Usage({ + description: + '\n This command will cause a package to be extracted in a temporary directory (under a folder named "patch-workdir"). This folder will be editable at will; running `yarn patch` inside it will then cause Yarn to generate a patchfile and register it into your top-level manifest (cf the `patch:` protocol).\n ', + })), + (0, W.gn)([Z.Command.String()], te.prototype, 'package', void 0), + (0, W.gn)([Z.Command.Path('patch')], te.prototype, 'execute', null); + const re = { + configuration: { + enableInlineHunks: { + description: + 'If true, the installs will print unmatched patch hunks', + type: n.a2.BOOLEAN, + default: !1, + }, + }, + commands: [$, te], + fetchers: [ + class { + supports(e, t) { + return !!e.reference.startsWith('patch:'); + } + getLocalPath(e, t) { + return null; + } + async fetch(e, t) { + const r = t.checksums.get(e.locatorHash) || null, + [A, n, o] = await t.cache.fetchPackageFromCache(e, r, { + onHit: () => t.report.reportCacheHit(e), + onMiss: () => + t.report.reportCacheMiss( + e, + s.prettyLocator(t.project.configuration, e) + + " can't be found in the cache and will be fetched from the disk" + ), + loader: () => this.patchPackage(e, t), + skipIntegrityCheck: t.skipIntegrityCheck, + }); + return { + packageFs: A, + releaseFs: n, + prefixPath: s.getIdentVendorPath(e), + localPath: this.getLocalPath(e, t), + checksum: o, + }; + } + async patchPackage(e, t) { + const { + parentLocator: r, + sourceLocator: A, + sourceVersion: n, + patchPaths: p, + } = L(e), + d = await Y(r, p, t), + C = await c.xfs.mktempPromise(), + f = g.y1.join(C, 'patched.zip'), + E = await t.fetcher.fetch(A, t), + B = s.getIdentVendorPath(e), + y = await (0, h.getLibzipPromise)(), + m = new l.d(f, { + libzip: y, + create: !0, + level: t.project.configuration.get('compressionLevel'), + }); + await m.mkdirpPromise(B), + await a.releaseAfterUseAsync(async () => { + await m.copyPromise(B, E.prefixPath, { + baseFs: E.packageFs, + stableSort: !0, + }); + }, E.releaseFs); + const w = new u.M(g.y1.resolve(g.LZ.root, B), { baseFs: m }); + for (const e of d) + if (null !== e) + try { + await S(D(e), { baseFs: w, version: n }); + } catch (e) { + if (!(e instanceof I)) throw e; + const r = t.project.configuration.get( + 'enableInlineHunks' + ), + A = r ? '' : ' (set enableInlineHunks for details)'; + throw new o.lk( + i.b.PATCH_HUNK_FAILED, + e.message + A, + (A) => { + r && + q(e.hunk, { + configuration: t.project.configuration, + report: A, + }); + } + ); + } + return m; + } + }, + ], + resolvers: [ + class { + supportsDescriptor(e, t) { + return !!e.range.startsWith('patch:'); + } + supportsLocator(e, t) { + return !!e.reference.startsWith('patch:'); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + const { patchPaths: A } = x(e); + return A.every((e) => !j(e)) + ? e + : s.bindDescriptor(e, { locator: s.stringifyLocator(t) }); + } + getResolutionDependencies(e, t) { + const { sourceDescriptor: r } = x(e); + return [r]; + } + async getCandidates(e, t, r) { + if (!r.fetchOptions) + throw new Error( + 'Assertion failed: This resolver cannot be used unless a fetcher is configured' + ); + const { + parentLocator: A, + sourceDescriptor: n, + patchPaths: o, + } = x(e), + i = await Y(A, o, r.fetchOptions), + s = t.get(n.descriptorHash); + if (void 0 === s) + throw new Error( + 'Assertion failed: The dependency should have been resolved' + ); + return [ + U(e, { + parentLocator: A, + sourcePackage: s, + patchPaths: o, + patchHash: z.makeHash('2', ...i).slice(0, 6), + }), + ]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + const { sourceLocator: r } = L(e); + return { ...(await t.resolver.resolve(r, t)), ...e }; + } + }, + ], + }; + }, + 83228: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + PnpInstaller: () => k, + PnpLinker: () => S, + default: () => Y, + getPnpPath: () => T, + jsInstallUtils: () => A, + pnpUtils: () => n, + quotePathIfNeeded: () => j, + }); + var A = {}; + r.r(A), + r.d(A, { + checkAndReportManifestCompatibility: () => y, + extractBuildScripts: () => m, + getExtractHint: () => Q, + hasBindingGyp: () => D, + }); + var n = {}; + r.r(n), r.d(n, { getUnpluggedPath: () => b }); + var o = r(39922), + i = r(43896), + s = r(46009), + a = r(53887), + c = r.n(a), + g = r(54143), + l = r(71643), + u = r(73632), + h = r(32485), + p = r(92659), + d = r(46611), + C = r(17674), + f = r(75448), + I = r(34432), + E = r(40822), + B = r(92409); + function y(e, t, r, { configuration: A, report: n }) { + return d.G.isManifestFieldCompatible(t.manifest.os, process.platform) + ? !!d.G.isManifestFieldCompatible(t.manifest.cpu, process.arch) || + (null == n || + n.reportWarningOnce( + p.b.INCOMPATIBLE_CPU, + `${g.prettyLocator(A, e)} The CPU architecture ${ + process.arch + } is incompatible with this module, ${r} skipped.` + ), + !1) + : (null == n || + n.reportWarningOnce( + p.b.INCOMPATIBLE_OS, + `${g.prettyLocator(A, e)} The platform ${ + process.platform + } is incompatible with this module, ${r} skipped.` + ), + !1); + } + function m(e, t, r, { configuration: A, report: n }) { + const o = []; + for (const e of ['preinstall', 'install', 'postinstall']) + t.manifest.scripts.has(e) && o.push([B.k.SCRIPT, e]); + if ( + (!t.manifest.scripts.has('install') && + t.misc.hasBindingGyp && + o.push([B.k.SHELLCODE, 'node-gyp rebuild']), + 0 === o.length) + ) + return []; + if (!A.get('enableScripts') && !r.built) + return ( + null == n || + n.reportWarningOnce( + p.b.DISABLED_BUILD_SCRIPTS, + g.prettyLocator(A, e) + + ' lists build scripts, but all build scripts have been disabled.' + ), + [] + ); + if (e.linkType !== h.Un.HARD) + return ( + null == n || + n.reportWarningOnce( + p.b.SOFT_LINK_BUILD, + g.prettyLocator(A, e) + + " lists build scripts, but is referenced through a soft link. Soft links don't support build scripts, so they'll be ignored." + ), + [] + ); + if (r && !1 === r.built) + return ( + null == n || + n.reportInfoOnce( + p.b.BUILD_DISABLED, + g.prettyLocator(A, e) + + ' lists build scripts, but its build has been explicitly disabled through configuration.' + ), + [] + ); + return y(e, t, 'build', { configuration: A, report: n }) ? o : []; + } + const w = new Set([ + '.exe', + '.h', + '.hh', + '.hpp', + '.c', + '.cc', + '.cpp', + '.java', + '.jar', + '.node', + ]); + function Q(e) { + return e.packageFs.getExtractHint({ relevantExtensions: w }); + } + function D(e) { + const t = s.y1.join(e.prefixPath, 'binding.gyp'); + return e.packageFs.existsSync(t); + } + function b(e, { configuration: t }) { + return s.y1.resolve(t.get('pnpUnpluggedFolder'), g.slugifyLocator(e)); + } + const v = new Set([ + g.makeIdent(null, 'nan').identHash, + g.makeIdent(null, 'node-gyp').identHash, + g.makeIdent(null, 'node-pre-gyp').identHash, + g.makeIdent(null, 'node-addon-api').identHash, + g.makeIdent(null, 'fsevents').identHash, + ]); + class S { + constructor() { + this.mode = 'strict'; + } + supportsPackage(e, t) { + return ( + 'pnp' === t.project.configuration.get('nodeLinker') && + t.project.configuration.get('pnpMode') === this.mode + ); + } + async findPackageLocation(e, t) { + const r = T(t.project).main; + if (!i.xfs.existsSync(r)) + throw new E.UsageError( + `The project in ${l.pretty( + t.project.configuration, + t.project.cwd + '/package.json', + l.Type.PATH + )} doesn't seem to have been installed - running an install there might help` + ); + const A = u.dynamicRequireNoCache(r), + n = { name: g.requirableIdent(e), reference: e.reference }, + o = A.getPackageInformation(n); + if (!o) + throw new E.UsageError( + `Couldn't find ${g.prettyLocator( + t.project.configuration, + e + )} in the currently installed PnP map - running an install might help` + ); + return s.cS.toPortablePath(o.packageLocation); + } + async findPackageLocator(e, t) { + const A = T(t.project).main; + if (!i.xfs.existsSync(A)) return null; + const n = s.cS.fromPortablePath(A), + o = u.dynamicRequire(n); + delete r.c[n]; + const a = o.findPackageLocator(s.cS.fromPortablePath(e)); + return a ? g.makeLocator(g.parseIdent(a.name), a.reference) : null; + } + makeInstaller(e) { + return new k(e); + } + } + class k { + constructor(e) { + (this.opts = e), + (this.mode = 'strict'), + (this.packageRegistry = new Map()), + (this.virtualTemplates = new Map()), + (this.customData = { store: new Map() }), + (this.unpluggedPaths = new Set()), + (this.opts = e); + } + getCustomDataKey() { + return JSON.stringify({ name: 'PnpInstaller', version: 1 }); + } + attachCustomData(e) { + this.customData = e; + } + async installPackage(e, t) { + const r = g.requirableIdent(e), + A = e.reference, + n = !!this.opts.project.tryWorkspaceByLocator(e), + o = e.peerDependencies.size > 0 && !g.isVirtualLocator(e), + i = !o && !n, + a = !o && e.linkType !== h.Un.SOFT; + let c = this.customData.store.get(e.locatorHash); + void 0 === c && + ((c = await (async function (e, t) { + var r; + const A = + null !== + (r = await d.G.tryFind(t.prefixPath, { + baseFs: t.packageFs, + })) && void 0 !== r + ? r + : new d.G(), + n = new Set(['preinstall', 'install', 'postinstall']); + for (const e of A.scripts.keys()) + n.has(e) || A.scripts.delete(e); + return { + manifest: { + os: A.os, + cpu: A.cpu, + scripts: A.scripts, + preferUnplugged: A.preferUnplugged, + }, + misc: { extractHint: Q(t), hasBindingGyp: D(t) }, + }; + })(0, t)), + e.linkType === h.Un.HARD && + this.customData.store.set(e.locatorHash, c)); + const l = this.opts.project.getDependencyMeta(e, e.version), + p = i + ? m(e, c, l, { + configuration: this.opts.project.configuration, + report: this.opts.report, + }) + : [], + f = a + ? await this.unplugPackageIfNeeded(e, c, t, l) + : t.packageFs; + if (s.y1.isAbsolute(t.prefixPath)) + throw new Error( + `Assertion failed: Expected the prefix path (${t.prefixPath}) to be relative to the parent` + ); + const I = s.y1.resolve(f.getRealPath(), t.prefixPath), + E = N(this.opts.project.cwd, I), + B = new Map(), + y = new Set(); + if (g.isVirtualLocator(e)) { + for (const t of e.peerDependencies.values()) + B.set(g.requirableIdent(t), null), y.add(g.stringifyIdent(t)); + if (!this.opts.project.tryWorkspaceByLocator(e)) { + const t = g.devirtualizeLocator(e); + this.virtualTemplates.set(t.locatorHash, { + location: N(this.opts.project.cwd, C.p.resolveVirtual(I)), + locator: t, + }); + } + } + return ( + u.getMapWithDefault(this.packageRegistry, r).set(A, { + packageLocation: E, + packageDependencies: B, + packagePeers: y, + linkType: e.linkType, + discardFromLookup: t.discardFromLookup || !1, + }), + { packageLocation: I, buildDirective: p.length > 0 ? p : null } + ); + } + async attachInternalDependencies(e, t) { + const r = this.getPackageInformation(e); + for (const [e, A] of t) { + const t = g.areIdentsEqual(e, A) + ? A.reference + : [g.requirableIdent(A), A.reference]; + r.packageDependencies.set(g.requirableIdent(e), t); + } + } + async attachExternalDependents(e, t) { + for (const r of t) { + this.getDiskInformation(r).packageDependencies.set( + g.requirableIdent(e), + e.reference + ); + } + } + async finalizeInstall() { + const e = new Set(); + for (const { + locator: e, + location: t, + } of this.virtualTemplates.values()) + u.getMapWithDefault( + this.packageRegistry, + g.stringifyIdent(e) + ).set(e.reference, { + packageLocation: t, + packageDependencies: new Map(), + packagePeers: new Set(), + linkType: h.Un.SOFT, + discardFromLookup: !1, + }); + this.packageRegistry.set( + null, + new Map([ + [ + null, + this.getPackageInformation( + this.opts.project.topLevelWorkspace.anchoredLocator + ), + ], + ]) + ); + const t = this.opts.project.configuration.get('pnpFallbackMode'), + r = e, + A = this.opts.project.workspaces.map( + ({ anchoredLocator: e }) => ({ + name: g.requirableIdent(e), + reference: e.reference, + }) + ), + n = 'none' !== t, + o = [], + i = new Map(), + s = u.buildIgnorePattern([ + '.yarn/sdks/**', + ...this.opts.project.configuration.get('pnpIgnorePatterns'), + ]), + a = this.packageRegistry, + c = this.opts.project.configuration.get('pnpShebang'); + if ('dependencies-only' === t) + for (const e of this.opts.project.storedPackages.values()) + this.opts.project.tryWorkspaceByLocator(e) && + o.push({ + name: g.requirableIdent(e), + reference: e.reference, + }); + return ( + await this.finalizeInstallWithPnp({ + blacklistedLocations: r, + dependencyTreeRoots: A, + enableTopLevelFallback: n, + fallbackExclusionList: o, + fallbackPool: i, + ignorePattern: s, + packageRegistry: a, + shebang: c, + }), + { customData: this.customData } + ); + } + async finalizeInstallWithPnp(e) { + if (this.opts.project.configuration.get('pnpMode') !== this.mode) + return; + const t = T(this.opts.project), + r = this.opts.project.configuration.get('pnpDataPath'); + if ( + (await i.xfs.removePromise(t.other), + 'pnp' !== this.opts.project.configuration.get('nodeLinker')) + ) + return ( + await i.xfs.removePromise(t.main), + void (await i.xfs.removePromise(r)) + ); + const A = await this.locateNodeModules(e.ignorePattern); + if (A.length > 0) { + this.opts.report.reportWarning( + p.b.DANGEROUS_NODE_MODULES, + 'One or more node_modules have been detected and will be removed. This operation may take some time.' + ); + for (const e of A) await i.xfs.removePromise(e); + } + if (this.opts.project.configuration.get('pnpEnableInlining')) { + const A = (0, I.gY)(e); + await i.xfs.changeFilePromise(t.main, A, { + automaticNewlines: !0, + }), + await i.xfs.chmodPromise(t.main, 493), + await i.xfs.removePromise(r); + } else { + const A = s.y1.relative(s.y1.dirname(t.main), r), + { dataFile: n, loaderFile: o } = (0, I.Q$)({ + ...e, + dataLocation: A, + }); + await i.xfs.changeFilePromise(t.main, o, { + automaticNewlines: !0, + }), + await i.xfs.chmodPromise(t.main, 493), + await i.xfs.changeFilePromise(r, n, { automaticNewlines: !0 }), + await i.xfs.chmodPromise(r, 420); + } + const n = this.opts.project.configuration.get('pnpUnpluggedFolder'); + if (0 === this.unpluggedPaths.size) await i.xfs.removePromise(n); + else + for (const e of await i.xfs.readdirPromise(n)) { + const t = s.y1.resolve(n, e); + this.unpluggedPaths.has(t) || (await i.xfs.removePromise(t)); + } + } + async locateNodeModules(e) { + const t = [], + r = e ? new RegExp(e) : null; + for (const e of this.opts.project.workspaces) { + const A = s.y1.join(e.cwd, 'node_modules'); + if ( + (r && r.test(s.y1.relative(this.opts.project.cwd, e.cwd))) || + !i.xfs.existsSync(A) + ) + continue; + const n = await i.xfs.readdirPromise(A, { withFileTypes: !0 }), + o = n.filter( + (e) => + !e.isDirectory() || + '.bin' === e.name || + !e.name.startsWith('.') + ); + if (o.length === n.length) t.push(A); + else for (const e of o) t.push(s.y1.join(A, e.name)); + } + return t; + } + async unplugPackageIfNeeded(e, t, r, A) { + return this.shouldBeUnplugged(e, t, A) + ? this.unplugPackage(e, r) + : r.packageFs; + } + shouldBeUnplugged(e, t, r) { + return void 0 !== r.unplugged + ? r.unplugged + : !!v.has(e.identHash) || + (null !== t.manifest.preferUnplugged + ? t.manifest.preferUnplugged + : !!( + m(e, t, r, { + configuration: this.opts.project.configuration, + }).length > 0 || t.misc.extractHint + )); + } + async unplugPackage(e, t) { + const r = b(e, { configuration: this.opts.project.configuration }); + this.unpluggedPaths.add(r); + const A = s.y1.join(r, t.prefixPath, '.ready'); + return ( + (await i.xfs.existsPromise(A)) || + (await i.xfs.mkdirPromise(r, { recursive: !0 }), + await i.xfs.copyPromise(r, s.LZ.dot, { + baseFs: t.packageFs, + overwrite: !1, + }), + await i.xfs.writeFilePromise(A, '')), + new f.M(r) + ); + } + getPackageInformation(e) { + const t = g.requirableIdent(e), + r = e.reference, + A = this.packageRegistry.get(t); + if (!A) + throw new Error( + `Assertion failed: The package information store should have been available (for ${g.prettyIdent( + this.opts.project.configuration, + e + )})` + ); + const n = A.get(r); + if (!n) + throw new Error( + `Assertion failed: The package information should have been available (for ${g.prettyLocator( + this.opts.project.configuration, + e + )})` + ); + return n; + } + getDiskInformation(e) { + const t = u.getMapWithDefault(this.packageRegistry, '@@disk'), + r = N(this.opts.project.cwd, e); + return u.getFactoryWithDefault(t, r, () => ({ + packageLocation: r, + packageDependencies: new Map(), + packagePeers: new Set(), + linkType: h.Un.SOFT, + discardFromLookup: !1, + })); + } + } + function N(e, t) { + let r = s.y1.relative(e, t); + return ( + r.match(/^\.{0,2}\//) || (r = './' + r), r.replace(/\/?$/, '/') + ); + } + var F = r(36370), + K = r(25413), + M = r(85824), + R = r(28148), + x = r(15815), + L = r(36545), + P = r(2401), + O = r.n(P); + class U extends K.BaseCommand { + constructor() { + super(...arguments), + (this.patterns = []), + (this.all = !1), + (this.recursive = !1), + (this.json = !1); + } + async execute() { + const e = await o.VK.find(this.context.cwd, this.context.plugins), + { project: t, workspace: r } = await M.I.find( + e, + this.context.cwd + ), + A = await R.C.find(e); + if (!r) throw new K.WorkspaceRequiredError(t.cwd, this.context.cwd); + if ('pnp' !== e.get('nodeLinker')) + throw new E.UsageError( + 'This command can only be used if the `nodeLinker` option is set to `pnp`' + ); + await t.restoreInstallState(); + const n = new Set(this.patterns), + i = this.patterns.map((t) => { + const r = g.parseDescriptor(t), + A = 'unknown' !== r.range ? r : g.makeDescriptor(r, '*'); + if (!c().validRange(A.range)) + throw new E.UsageError( + `The range of the descriptor patterns must be a valid semver range (${g.prettyDescriptor( + e, + A + )})` + ); + return (e) => { + const r = g.stringifyIdent(e); + return ( + !!O().isMatch(r, g.stringifyIdent(A)) && + !( + e.version && + !L.satisfiesWithPrereleases(e.version, A.range) + ) && + (n.delete(t), !0) + ); + }; + }), + s = (e) => { + const r = new Set(), + A = [], + n = (e, o) => { + if ( + !r.has(e.locatorHash) && + (r.add(e.locatorHash), + !t.tryWorkspaceByLocator(e) && + i.some((t) => t(e)) && + A.push(e), + !(o > 0) || this.recursive) + ) + for (const r of e.dependencies.values()) { + const e = t.storedResolutions.get(r.descriptorHash); + if (!e) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + const A = t.storedPackages.get(e); + if (!A) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + n(A, o + 1); + } + }; + for (const r of e) { + const e = t.storedPackages.get(r.anchoredLocator.locatorHash); + if (!e) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + n(e, 0); + } + return A; + }; + let a, h; + if ( + (this.all && this.recursive + ? ((a = (() => { + const e = []; + for (const r of t.storedPackages.values()) + t.tryWorkspaceByLocator(r) || + g.isVirtualLocator(r) || + !i.some((e) => e(r)) || + e.push(r); + return e; + })()), + (h = 'the project')) + : this.all + ? ((a = s(t.workspaces)), (h = 'any workspace')) + : ((a = s([r])), (h = 'this workspace')), + n.size > 1) + ) + throw new E.UsageError( + `Patterns ${l.prettyList( + e, + n, + l.Type.CODE + )} don't match any packages referenced by ${h}` + ); + if (n.size > 0) + throw new E.UsageError( + `Pattern ${l.prettyList( + e, + n, + l.Type.CODE + )} doesn't match any packages referenced by ${h}` + ); + a = u.sortMap(a, (e) => g.stringifyLocator(e)); + return ( + await x.Pk.start( + { + configuration: e, + stdout: this.context.stdout, + json: this.json, + }, + async (r) => { + var n; + for (const A of a) { + const o = + null !== (n = A.version) && void 0 !== n ? n : 'unknown'; + (t.topLevelWorkspace.manifest.ensureDependencyMeta( + g.makeDescriptor(A, o) + ).unplugged = !0), + r.reportInfo( + p.b.UNNAMED, + `Will unpack ${g.prettyLocator(e, A)} to ${l.pretty( + e, + b(A, { configuration: e }), + l.Type.PATH + )}` + ), + r.reportJson({ + locator: g.stringifyLocator(A), + version: o, + }); + } + await t.topLevelWorkspace.persistManifest(), + r.reportSeparator(), + await t.install({ cache: A, report: r }); + } + ) + ).exitCode(); + } + } + (U.usage = E.Command.Usage({ + description: 'force the unpacking of a list of packages', + details: + "\n This command will add the selectors matching the specified patterns to the list of packages that must be unplugged when installed.\n\n A package being unplugged means that instead of being referenced directly through its archive, it will be unpacked at install time in the directory configured via `pnpUnpluggedFolder`. Note that unpacking packages this way is generally not recommended because it'll make it harder to store your packages within the repository. However, it's a good approach to quickly and safely debug some packages, and can even sometimes be required depending on the context (for example when the package contains shellscripts).\n\n Running the command will set a persistent flag inside your top-level `package.json`, in the `dependenciesMeta` field. As such, to undo its effects, you'll need to revert the changes made to the manifest and run `yarn install` to apply the modification.\n\n By default, only direct dependencies from the current workspace are affected. If `-A,--all` is set, direct dependencies from the entire project are affected. Using the `-R,--recursive` flag will affect transitive dependencies as well as direct ones.\n\n This command accepts glob patterns inside the scope and name components (not the range). Make sure to escape the patterns to prevent your own shell from trying to expand them.\n ", + examples: [ + [ + 'Unplug the lodash dependency from the active workspace', + 'yarn unplug lodash', + ], + [ + 'Unplug all instances of lodash referenced by any workspace', + 'yarn unplug lodash -A', + ], + [ + 'Unplug all instances of lodash referenced by the active workspace and its dependencies', + 'yarn unplug lodash -R', + ], + [ + 'Unplug all instances of lodash, anywhere', + 'yarn unplug lodash -AR', + ], + [ + 'Unplug one specific version of lodash', + 'yarn unplug lodash@1.2.3', + ], + [ + 'Unplug all packages with the `@babel` scope', + "yarn unplug '@babel/*'", + ], + [ + 'Unplug all packages (only for testing, not recommended)', + "yarn unplug -R '*'", + ], + ], + })), + (0, F.gn)([E.Command.Rest()], U.prototype, 'patterns', void 0), + (0, F.gn)( + [ + E.Command.Boolean('-A,--all', { + description: + 'Unplug direct dependencies from the entire project', + }), + ], + U.prototype, + 'all', + void 0 + ), + (0, F.gn)( + [ + E.Command.Boolean('-R,--recursive', { + description: 'Unplug both direct and transitive dependencies', + }), + ], + U.prototype, + 'recursive', + void 0 + ), + (0, F.gn)( + [ + E.Command.Boolean('--json', { + description: 'Format the output as an NDJSON stream', + }), + ], + U.prototype, + 'json', + void 0 + ), + (0, F.gn)([E.Command.Path('unplug')], U.prototype, 'execute', null); + const T = (e) => { + let t, r; + return ( + 'module' === e.topLevelWorkspace.manifest.type + ? ((t = '.pnp.cjs'), (r = '.pnp.js')) + : ((t = '.pnp.js'), (r = '.pnp.cjs')), + { main: s.y1.join(e.cwd, t), other: s.y1.join(e.cwd, r) } + ); + }, + j = (e) => (/\s/.test(e) ? JSON.stringify(e) : e); + const Y = { + hooks: { + populateYarnPaths: async function (e, t) { + t(T(e).main), + t(T(e).other), + t(e.configuration.get('pnpDataPath')), + t(e.configuration.get('pnpUnpluggedFolder')); + }, + setupScriptEnvironment: async function (e, t, r) { + const A = T(e).main, + n = '--require ' + j(s.cS.fromPortablePath(A)); + if (A.includes(' ') && c().lt(process.versions.node, '12.0.0')) + throw new Error( + `Expected the build location to not include spaces when using Node < 12.0.0 (${process.versions.node})` + ); + if (i.xfs.existsSync(A)) { + let e = t.NODE_OPTIONS || ''; + const r = /\s*--require\s+\S*\.pnp\.c?js\s*/g; + (e = e.replace(r, ' ').trim()), + (e = e ? `${n} ${e}` : n), + (t.NODE_OPTIONS = e); + } + }, + }, + configuration: { + nodeLinker: { + description: + 'The linker used for installing Node packages, one of: "pnp", "node-modules"', + type: o.a2.STRING, + default: 'pnp', + }, + pnpMode: { + description: + "If 'strict', generates standard PnP maps. If 'loose', merges them with the n_m resolution.", + type: o.a2.STRING, + default: 'strict', + }, + pnpShebang: { + description: 'String to prepend to the generated PnP script', + type: o.a2.STRING, + default: '#!/usr/bin/env node', + }, + pnpIgnorePatterns: { + description: + 'Array of glob patterns; files matching them will use the classic resolution', + type: o.a2.STRING, + default: [], + isArray: !0, + }, + pnpEnableInlining: { + description: + 'If true, the PnP data will be inlined along with the generated loader', + type: o.a2.BOOLEAN, + default: !0, + }, + pnpFallbackMode: { + description: + 'If true, the generated PnP loader will follow the top-level fallback rule', + type: o.a2.STRING, + default: 'dependencies-only', + }, + pnpUnpluggedFolder: { + description: 'Folder where the unplugged packages must be stored', + type: o.a2.ABSOLUTE_PATH, + default: './.yarn/unplugged', + }, + pnpDataPath: { + description: + 'Path of the file where the PnP data (used by the loader) must be written', + type: o.a2.ABSOLUTE_PATH, + default: './.pnp.data.json', + }, + }, + linkers: [S], + commands: [U], + }; + }, + 43418: (e, t, r) => { + 'use strict'; + r.r(t); + var A = r(50683), + n = r.n(A); + Object.fromEntries || (Object.fromEntries = n()); + var o = r(59355), + i = r(10419), + s = r(45330); + (0, i.D)({ + binaryVersion: o.o || '', + pluginConfiguration: (0, s.e)(), + }); + }, + 25413: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + BaseCommand: () => A.F, + WorkspaceRequiredError: () => s, + getDynamicLibs: () => c, + getPluginConfiguration: () => g.e, + main: () => h.D, + openWorkspace: () => u, + pluginCommands: () => p.f, + }); + var A = r(56087), + n = r(46611), + o = r(46009), + i = r(40822); + class s extends i.UsageError { + constructor(e, t) { + super( + `This command can only be run from within a workspace of your project (${o.y1.relative( + e, + t + )} isn't a workspace of ${o.y1.join(e, n.G.fileName)}).` + ); + } + } + const a = [ + '@yarnpkg/cli', + '@yarnpkg/core', + '@yarnpkg/fslib', + '@yarnpkg/libzip', + '@yarnpkg/parsers', + '@yarnpkg/shell', + 'clipanion', + 'semver', + 'yup', + ], + c = () => new Map(a.map((e) => [e, r(98497)(e)])); + var g = r(45330), + l = r(85824); + async function u(e, t) { + const { project: r, workspace: A } = await l.I.find(e, t); + if (!A) throw new s(r.cwd, t); + return A; + } + var h = r(10419), + p = r(15683); + }, + 10419: (e, t, r) => { + 'use strict'; + r.d(t, { D: () => f }); + var A = r(36545), + n = r(39922), + o = r(81832), + i = r(43896), + s = r(46009), + a = r(63129), + c = r(5864), + g = r(40822), + l = r(35747), + u = r(15683), + h = r(36370), + p = r(71643), + d = r(56087); + class C extends d.F { + async execute() { + const e = await n.VK.find(this.context.cwd, this.context.plugins); + this.context.stdout.write( + ((e) => + `\n${p.pretty( + e, + 'Welcome on Yarn 2!', + 'bold' + )} 🎉 Thanks for helping us shape our vision of how projects\nshould be managed going forward.\n\nBeing still in RC, Yarn 2 isn't completely stable yet. Some features might be\nmissing, and some behaviors may have received major overhaul. In case of doubt,\nuse the following URLs to get some insight:\n\n - The changelog:\n ${p.pretty( + e, + 'https://github.com/yarnpkg/berry/tree/CHANGELOG.md', + 'cyan' + )}\n\n - Our issue tracker:\n ${p.pretty( + e, + 'https://github.com/yarnpkg/berry', + 'cyan' + )}\n\n - Our Discord server:\n ${p.pretty( + e, + 'https://discord.gg/yarnpkg', + 'cyan' + )}\n\nWe're hoping you will enjoy the experience. For now, a good start is to run\nthe two following commands:\n\n ${p.pretty( + e, + 'find . -name node_modules -prune -exec rm -r {} \\;', + 'magenta' + )}\n ${p.pretty( + e, + 'yarn install', + 'magenta' + )}\n\nOne last trick! If you need at some point to upgrade Yarn to a nightly build,\nthe following command will install the CLI straight from master:\n\n ${p.pretty( + e, + 'yarn set version from sources', + 'magenta' + )}\n\nSee you later 👋\n`)(e).trim() + '\n' + ); + } + } + async function f({ binaryVersion: e, pluginConfiguration: t }) { + async function r() { + const h = new g.Cli({ + binaryLabel: 'Yarn Package Manager', + binaryName: 'yarn', + binaryVersion: e, + }); + h.register(C); + try { + await (async function h(p) { + var d, C, f, I, E; + const B = process.versions.node, + y = '>=10.17 <14 || >14.1'; + if ( + '1' !== process.env.YARN_IGNORE_NODE && + !A.satisfiesWithPrereleases(B, y) + ) + throw new g.UsageError( + `This tool requires a Node version compatible with ${y} (got ${B}). Upgrade Node, or set \`YARN_IGNORE_NODE=1\` in your environment.` + ); + const m = await n.VK.find( + s.cS.toPortablePath(process.cwd()), + t, + { usePath: !0, strict: !1 } + ), + w = m.get('yarnPath'), + Q = m.get('ignorePath'), + D = m.get('ignoreCwd'); + if ( + !Q && + !D && + w === s.cS.toPortablePath(s.cS.resolve(process.argv[1])) + ) + return ( + (process.env.YARN_IGNORE_PATH = '1'), + (process.env.YARN_IGNORE_CWD = '1'), + void (await h(p)) + ); + if (null === w || Q) { + Q && delete process.env.YARN_IGNORE_PATH; + m.get('enableTelemetry') && + !c.isCI && + process.stdout.isTTY && + (n.VK.telemetry = new o.E( + m, + 'puba9cdc10ec5790a2cf4969dd413a47270' + )), + null === (d = n.VK.telemetry) || + void 0 === d || + d.reportVersion(e); + for (const [e, t] of m.plugins.entries()) { + u.f.has( + null !== + (f = + null === (C = e.match(/^@yarnpkg\/plugin-(.*)$/)) || + void 0 === C + ? void 0 + : C[1]) && void 0 !== f + ? f + : '' + ) && + (null === (I = n.VK.telemetry) || + void 0 === I || + I.reportPluginName(e)); + for (const e of t.commands || []) p.register(e); + } + const A = p.process(process.argv.slice(2)); + A.help || + null === (E = n.VK.telemetry) || + void 0 === E || + E.reportCommandName(A.path.join(' ')); + const i = A.cwd; + if (void 0 !== i && !D) { + const e = (0, l.realpathSync)(process.cwd()), + t = (0, l.realpathSync)(i); + if (e !== t) return process.chdir(i), void (await r()); + } + await p.runExit(A, { + cwd: s.cS.toPortablePath(process.cwd()), + plugins: t, + quiet: !1, + stdin: process.stdin, + stdout: process.stdout, + stderr: process.stderr, + }); + } else if (i.xfs.existsSync(w)) + try { + !(function (e) { + const t = s.cS.fromPortablePath(e); + process.on('SIGINT', () => {}), + t + ? (0, a.execFileSync)( + process.execPath, + [t, ...process.argv.slice(2)], + { + stdio: 'inherit', + env: { + ...process.env, + YARN_IGNORE_PATH: '1', + YARN_IGNORE_CWD: '1', + }, + } + ) + : (0, a.execFileSync)(t, process.argv.slice(2), { + stdio: 'inherit', + env: { + ...process.env, + YARN_IGNORE_PATH: '1', + YARN_IGNORE_CWD: '1', + }, + }); + })(w); + } catch (e) { + process.exitCode = e.code || 1; + } + else + process.stdout.write( + p.error( + new Error( + `The "yarn-path" option has been set (in ${m.sources.get( + 'yarnPath' + )}), but the specified location doesn't exist (${w}).` + ) + ) + ), + (process.exitCode = 1); + })(h); + } catch (e) { + process.stdout.write(h.error(e)), (process.exitCode = 1); + } + } + return r() + .catch((e) => { + process.stdout.write(e.stack || e.message), + (process.exitCode = 1); + }) + .finally(() => i.xfs.rmtempPromise()); + } + (0, h.gn)([g.Command.Path('--welcome')], C.prototype, 'execute', null); + }, + 15683: (e, t, r) => { + 'use strict'; + r.d(t, { f: () => A }); + const A = new Map([ + [ + 'constraints', + [ + ['constraints', 'query'], + ['constraints', 'source'], + ['constraints'], + ], + ], + ['exec', []], + ['interactive-tools', [['search'], ['upgrade-interactive']]], + ['stage', [['stage']]], + ['typescript', []], + [ + 'version', + [['version', 'apply'], ['version', 'check'], ['version']], + ], + [ + 'workspace-tools', + [ + ['workspaces', 'focus'], + ['workspaces', 'foreach'], + ], + ], + ]); + }, + 56087: (e, t, r) => { + 'use strict'; + r.d(t, { F: () => o }); + var A = r(36370), + n = r(40822); + class o extends n.Command {} + (0, A.gn)( + [n.Command.String('--cwd', { hidden: !0 })], + o.prototype, + 'cwd', + void 0 + ); + }, + 28148: (e, t, r) => { + 'use strict'; + r.d(t, { C: () => I }); + var A = r(78420), + n = r(15037), + o = r(90739), + i = r(14626), + s = r(46009), + a = r(43896), + c = r(65281), + g = r(35747), + l = r.n(g), + u = r(92659), + h = r(35691), + p = r(20624), + d = r(73632), + C = r(54143); + const f = 7; + class I { + constructor( + e, + { + configuration: t, + immutable: r = t.get('enableImmutableCache'), + check: A = !1, + } + ) { + (this.markedFiles = new Set()), + (this.mutexes = new Map()), + (this.configuration = t), + (this.cwd = e), + (this.immutable = r), + (this.check = A); + const n = t.get('cacheKeyOverride'); + if (null !== n) this.cacheKey = '' + n; + else { + const e = t.get('compressionLevel'), + r = e !== o.k ? 'c' + e : ''; + this.cacheKey = [f, r].join(''); + } + } + static async find(e, { immutable: t, check: r } = {}) { + const A = new I(e.get('cacheFolder'), { + configuration: e, + immutable: t, + check: r, + }); + return await A.setup(), A; + } + get mirrorCwd() { + if (!this.configuration.get('enableMirror')) return null; + const e = this.configuration.get('globalFolder') + '/cache'; + return e !== this.cwd ? e : null; + } + getVersionFilename(e) { + return `${C.slugifyLocator(e)}-${this.cacheKey}.zip`; + } + getChecksumFilename(e, t) { + const r = (function (e) { + const t = e.indexOf('/'); + return -1 !== t ? e.slice(t + 1) : e; + })(t).slice(0, 10); + return `${C.slugifyLocator(e)}-${r}.zip`; + } + getLocatorPath(e, t) { + if (null === this.mirrorCwd) + return s.y1.resolve(this.cwd, this.getVersionFilename(e)); + if (null === t) return null; + return E(t) !== this.cacheKey + ? null + : s.y1.resolve(this.cwd, this.getChecksumFilename(e, t)); + } + getLocatorMirrorPath(e) { + const t = this.mirrorCwd; + return null !== t + ? s.y1.resolve(t, this.getVersionFilename(e)) + : null; + } + async setup() { + if (!this.configuration.get('enableGlobalCache')) { + await a.xfs.mkdirPromise(this.cwd, { recursive: !0 }); + const e = s.y1.resolve(this.cwd, '.gitignore'); + await a.xfs.changeFilePromise(e, '/.gitignore\n*.flock\n'); + } + } + async fetchPackageFromCache( + e, + t, + { onHit: r, onMiss: g, loader: f, skipIntegrityCheck: I } + ) { + const B = this.getLocatorMirrorPath(e), + y = new A.S(), + m = async (e, r = null) => { + const A = + I && t ? t : `${this.cacheKey}/${await p.checksumFile(e)}`; + if (null !== r) { + if ( + A !== + (I && t ? t : `${this.cacheKey}/${await p.checksumFile(r)}`) + ) + throw new h.lk( + u.b.CACHE_CHECKSUM_MISMATCH, + "The remote archive doesn't match the local checksum - has the local cache been corrupted?" + ); + } + if (null !== t && A !== t) { + let e; + switch ( + ((e = this.check + ? 'throw' + : E(t) !== E(A) + ? 'update' + : this.configuration.get('checksumBehavior')), + e) + ) { + case 'ignore': + return t; + case 'update': + return A; + default: + case 'throw': + throw new h.lk( + u.b.CACHE_CHECKSUM_MISMATCH, + "The remote archive doesn't match the expected checksum" + ); + } + } + return A; + }, + w = async (t) => { + if (!f) + throw new Error( + 'Cache check required but no loader configured for ' + + C.prettyLocator(this.configuration, e) + ); + const r = await f(), + A = r.getRealPath(); + return ( + r.saveAndClose(), + await a.xfs.chmodPromise(A, 420), + await m(t, A) + ); + }, + Q = async () => { + if (null === B || !(await a.xfs.existsPromise(B))) { + const e = await f(), + t = e.getRealPath(); + return e.saveAndClose(), t; + } + const t = await a.xfs.mktempPromise(), + r = s.y1.join(t, this.getVersionFilename(e)); + return ( + await a.xfs.copyFilePromise( + B, + r, + l().constants.COPYFILE_FICLONE + ), + r + ); + }, + D = async () => { + if (!f) + throw new Error( + 'Cache entry required but missing for ' + + C.prettyLocator(this.configuration, e) + ); + if (this.immutable) + throw new h.lk( + u.b.IMMUTABLE_CACHE, + 'Cache entry required but missing for ' + + C.prettyLocator(this.configuration, e) + ); + const t = await Q(); + await a.xfs.chmodPromise(t, 420); + const r = await m(t), + A = this.getLocatorPath(e, r); + if (!A) + throw new Error( + 'Assertion failed: Expected the cache path to be available' + ); + return await this.writeFileWithLock( + A, + async () => + await this.writeFileWithLock( + B, + async () => ( + await a.xfs.movePromise(t, A), + null !== B && + (await a.xfs.copyFilePromise( + A, + B, + l().constants.COPYFILE_FICLONE + )), + [A, r] + ) + ) + ); + }; + for (let t; (t = this.mutexes.get(e.locatorHash)); ) await t; + const [b, v] = await (async () => { + const A = (async () => { + const A = this.getLocatorPath(e, t), + n = null !== A && (await y.existsPromise(A)), + o = n ? r : g; + if ((o && o(), n)) { + let e = null; + const t = A; + return (e = this.check ? await w(t) : await m(t)), [t, e]; + } + return D(); + })(); + this.mutexes.set(e.locatorHash, A); + try { + return await A; + } finally { + this.mutexes.delete(e.locatorHash); + } + })(); + this.markedFiles.add(b); + let S = null; + const k = await (0, c.getLibzipPromise)(), + N = new n.v( + () => + d.prettifySyncErrors( + () => + (S = new o.d(b, { baseFs: y, libzip: k, readOnly: !0 })), + (t) => + `Failed to open the cache entry for ${C.prettyLocator( + this.configuration, + e + )}: ${t}` + ), + s.y1 + ); + return [ + new i.K(b, { baseFs: N, pathUtils: s.y1 }), + () => { + null !== S && S.discardAndClose(); + }, + v, + ]; + } + async writeFileWithLock(e, t) { + return null === e + ? await t() + : (await a.xfs.mkdirPromise(s.y1.dirname(e), { recursive: !0 }), + await a.xfs.lockPromise(e, async () => await t())); + } + } + function E(e) { + const t = e.indexOf('/'); + return -1 !== t ? e.slice(0, t) : null; + } + }, + 39922: (e, t, r) => { + 'use strict'; + r.d(t, { + VK: () => W, + nh: () => U, + tr: () => O, + a5: () => j, + EW: () => z, + a2: () => T, + }); + var A = r(43896), + n = r(46009), + o = r(90739), + i = r(11640), + s = r(54738), + a = r.n(s), + c = r(5864), + g = r(40822), + l = r(61578), + u = r.n(l), + h = r(53887), + p = r.n(h), + d = r(92413), + C = r(92659), + f = r(54143); + const I = { + hooks: { + reduceDependency: ( + e, + t, + r, + A, + { resolver: n, resolveOptions: o } + ) => { + for (const { pattern: A, reference: i } of t.topLevelWorkspace + .manifest.resolutions) { + if (A.from && A.from.fullName !== f.requirableIdent(r)) + continue; + if ( + A.from && + A.from.description && + A.from.description !== r.reference + ) + continue; + if (A.descriptor.fullName !== f.requirableIdent(e)) continue; + if ( + A.descriptor.description && + A.descriptor.description !== e.range + ) + continue; + return n.bindDescriptor( + f.makeDescriptor(e, i), + t.topLevelWorkspace.anchoredLocator, + o + ); + } + return e; + }, + validateProject: async (e, t) => { + for (const r of e.workspaces) { + const A = f.prettyWorkspace(e.configuration, r); + await e.configuration.triggerHook( + (e) => e.validateWorkspace, + r, + { + reportWarning: (e, r) => t.reportWarning(e, `${A}: ${r}`), + reportError: (e, r) => t.reportError(e, `${A}: ${r}`), + } + ); + } + }, + validateWorkspace: async (e, t) => { + const { manifest: r } = e; + r.resolutions.length && + e.cwd !== e.project.cwd && + r.errors.push(new Error('Resolutions field will be ignored')); + for (const e of r.errors) + t.reportWarning(C.b.INVALID_MANIFEST, e.message); + }, + }, + }; + var E = r(46611), + B = r(35691); + class y { + constructor(e) { + this.fetchers = e; + } + supports(e, t) { + return !!this.tryFetcher(e, t); + } + getLocalPath(e, t) { + return this.getFetcher(e, t).getLocalPath(e, t); + } + async fetch(e, t) { + const r = this.getFetcher(e, t); + return await r.fetch(e, t); + } + tryFetcher(e, t) { + const r = this.fetchers.find((r) => r.supports(e, t)); + return r || null; + } + getFetcher(e, t) { + const r = this.fetchers.find((r) => r.supports(e, t)); + if (!r) + throw new B.lk( + C.b.FETCHER_NOT_FOUND, + f.prettyLocator(t.project.configuration, e) + + " isn't supported by any available fetcher" + ); + return r; + } + } + var m = r(27092), + w = r(52779), + Q = r(60895); + class D { + static isVirtualDescriptor(e) { + return !!e.range.startsWith(D.protocol); + } + static isVirtualLocator(e) { + return !!e.reference.startsWith(D.protocol); + } + supportsDescriptor(e, t) { + return D.isVirtualDescriptor(e); + } + supportsLocator(e, t) { + return D.isVirtualLocator(e); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + throw new Error( + 'Assertion failed: calling "bindDescriptor" on a virtual descriptor is unsupported' + ); + } + getResolutionDependencies(e, t) { + throw new Error( + 'Assertion failed: calling "getResolutionDependencies" on a virtual descriptor is unsupported' + ); + } + async getCandidates(e, t, r) { + throw new Error( + 'Assertion failed: calling "getCandidates" on a virtual descriptor is unsupported' + ); + } + async getSatisfying(e, t, r) { + throw new Error( + 'Assertion failed: calling "getSatisfying" on a virtual descriptor is unsupported' + ); + } + async resolve(e, t) { + throw new Error( + 'Assertion failed: calling "resolve" on a virtual locator is unsupported' + ); + } + } + D.protocol = 'virtual:'; + var b = r(75448), + v = r(94538); + class S { + supports(e) { + return !!e.reference.startsWith(v.d.protocol); + } + getLocalPath(e, t) { + return this.getWorkspace(e, t).cwd; + } + async fetch(e, t) { + const r = this.getWorkspace(e, t).cwd; + return { + packageFs: new b.M(r), + prefixPath: n.LZ.dot, + localPath: r, + }; + } + getWorkspace(e, t) { + return t.project.getWorkspaceByCwd( + e.reference.slice(v.d.protocol.length) + ); + } + } + var k = r(81111), + N = r(71643), + F = r(73632), + K = r(32282), + M = r.n(K); + function R(e) { + return ('undefined' != typeof require ? require : r(32178))(e); + } + var x = r(36545), + L = r(32485); + const P = new Set([ + 'binFolder', + 'version', + 'flags', + 'profile', + 'gpg', + 'ignoreNode', + 'wrapOutput', + ]), + O = '.yarnrc.yml', + U = 'yarn.lock'; + var T; + !(function (e) { + (e.ANY = 'ANY'), + (e.BOOLEAN = 'BOOLEAN'), + (e.ABSOLUTE_PATH = 'ABSOLUTE_PATH'), + (e.LOCATOR = 'LOCATOR'), + (e.LOCATOR_LOOSE = 'LOCATOR_LOOSE'), + (e.NUMBER = 'NUMBER'), + (e.STRING = 'STRING'), + (e.SECRET = 'SECRET'), + (e.SHAPE = 'SHAPE'), + (e.MAP = 'MAP'); + })(T || (T = {})); + const j = N.Type, + Y = { + lastUpdateCheck: { + description: + 'Last timestamp we checked whether new Yarn versions were available', + type: T.STRING, + default: null, + }, + yarnPath: { + description: + 'Path to the local executable that must be used over the global one', + type: T.ABSOLUTE_PATH, + default: null, + }, + ignorePath: { + description: + 'If true, the local executable will be ignored when using the global one', + type: T.BOOLEAN, + default: !1, + }, + ignoreCwd: { + description: 'If true, the `--cwd` flag will be ignored', + type: T.BOOLEAN, + default: !1, + }, + cacheKeyOverride: { + description: + 'A global cache key override; used only for test purposes', + type: T.STRING, + default: null, + }, + globalFolder: { + description: 'Folder where are stored the system-wide settings', + type: T.ABSOLUTE_PATH, + default: k.getDefaultGlobalFolder(), + }, + cacheFolder: { + description: 'Folder where the cache files must be written', + type: T.ABSOLUTE_PATH, + default: './.yarn/cache', + }, + compressionLevel: { + description: + "Zip files compression level, from 0 to 9 or mixed (a variant of 9, which stores some files uncompressed, when compression doesn't yield good results)", + type: T.NUMBER, + values: ['mixed', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], + default: o.k, + }, + virtualFolder: { + description: + 'Folder where the virtual packages (cf doc) will be mapped on the disk (must be named $$virtual)', + type: T.ABSOLUTE_PATH, + default: './.yarn/$$virtual', + }, + bstatePath: { + description: + 'Path of the file where the current state of the built packages must be stored', + type: T.ABSOLUTE_PATH, + default: './.yarn/build-state.yml', + }, + lockfileFilename: { + description: + 'Name of the files where the Yarn dependency tree entries must be stored', + type: T.STRING, + default: U, + }, + installStatePath: { + description: + 'Path of the file where the install state will be persisted', + type: T.ABSOLUTE_PATH, + default: './.yarn/install-state.gz', + }, + immutablePatterns: { + description: + "Array of glob patterns; files matching them won't be allowed to change during immutable installs", + type: T.STRING, + default: [], + isArray: !0, + }, + rcFilename: { + description: + 'Name of the files where the configuration can be found', + type: T.STRING, + default: q(), + }, + enableGlobalCache: { + description: + 'If true, the system-wide cache folder will be used regardless of `cache-folder`', + type: T.BOOLEAN, + default: !1, + }, + enableAbsoluteVirtuals: { + description: + 'If true, the virtual symlinks will use absolute paths if required [non portable!!]', + type: T.BOOLEAN, + default: !1, + }, + enableColors: { + description: + 'If true, the CLI is allowed to use colors in its output', + type: T.BOOLEAN, + default: N.supportsColor, + defaultText: '', + }, + enableHyperlinks: { + description: + 'If true, the CLI is allowed to use hyperlinks in its output', + type: T.BOOLEAN, + default: N.supportsHyperlinks, + defaultText: '', + }, + enableInlineBuilds: { + description: + 'If true, the CLI will print the build output on the command line', + type: T.BOOLEAN, + default: c.isCI, + defaultText: '', + }, + enableProgressBars: { + description: + 'If true, the CLI is allowed to show a progress bar for long-running events', + type: T.BOOLEAN, + default: + !c.isCI && process.stdout.isTTY && process.stdout.columns > 22, + defaultText: '', + }, + enableTimers: { + description: + 'If true, the CLI is allowed to print the time spent executing commands', + type: T.BOOLEAN, + default: !0, + }, + preferAggregateCacheInfo: { + description: + 'If true, the CLI will only print a one-line report of any cache changes', + type: T.BOOLEAN, + default: c.isCI, + }, + preferInteractive: { + description: + 'If true, the CLI will automatically use the interactive mode when called from a TTY', + type: T.BOOLEAN, + default: !1, + }, + preferTruncatedLines: { + description: + 'If true, the CLI will truncate lines that would go beyond the size of the terminal', + type: T.BOOLEAN, + default: !1, + }, + progressBarStyle: { + description: + 'Which style of progress bar should be used (only when progress bars are enabled)', + type: T.STRING, + default: void 0, + defaultText: '', + }, + defaultLanguageName: { + description: + "Default language mode that should be used when a package doesn't offer any insight", + type: T.STRING, + default: 'node', + }, + defaultProtocol: { + description: + 'Default resolution protocol used when resolving pure semver and tag ranges', + type: T.STRING, + default: 'npm:', + }, + enableTransparentWorkspaces: { + description: + "If false, Yarn won't automatically resolve workspace dependencies unless they use the `workspace:` protocol", + type: T.BOOLEAN, + default: !0, + }, + enableMirror: { + description: + 'If true, the downloaded packages will be retrieved and stored in both the local and global folders', + type: T.BOOLEAN, + default: !0, + }, + enableNetwork: { + description: + 'If false, the package manager will refuse to use the network if required to', + type: T.BOOLEAN, + default: !0, + }, + httpProxy: { + description: + 'URL of the http proxy that must be used for outgoing http requests', + type: T.STRING, + default: null, + }, + httpsProxy: { + description: + 'URL of the http proxy that must be used for outgoing https requests', + type: T.STRING, + default: null, + }, + unsafeHttpWhitelist: { + description: + 'List of the hostnames for which http queries are allowed (glob patterns are supported)', + type: T.STRING, + default: [], + isArray: !0, + }, + httpTimeout: { + description: 'Timeout of each http request in milliseconds', + type: T.NUMBER, + default: 6e4, + }, + httpRetry: { + description: 'Retry times on http failure', + type: T.NUMBER, + default: 3, + }, + networkConcurrency: { + description: 'Maximal number of concurrent requests', + type: T.NUMBER, + default: 1 / 0, + }, + networkSettings: { + description: + 'Network settings per hostname (glob patterns are supported)', + type: T.MAP, + valueDefinition: { + description: '', + type: T.SHAPE, + properties: { + caFilePath: { + description: + 'Path to file containing one or multiple Certificate Authority signing certificates', + type: T.ABSOLUTE_PATH, + default: null, + }, + enableNetwork: { + description: + 'If false, the package manager will refuse to use the network if required to', + type: T.BOOLEAN, + default: null, + }, + httpProxy: { + description: + 'URL of the http proxy that must be used for outgoing http requests', + type: T.STRING, + default: null, + }, + httpsProxy: { + description: + 'URL of the http proxy that must be used for outgoing https requests', + type: T.STRING, + default: null, + }, + }, + }, + }, + caFilePath: { + description: + 'A path to a file containing one or multiple Certificate Authority signing certificates', + type: T.ABSOLUTE_PATH, + default: null, + }, + enableStrictSsl: { + description: 'If false, SSL certificate errors will be ignored', + type: T.BOOLEAN, + default: !0, + }, + logFilters: { + description: 'Overrides for log levels', + type: T.SHAPE, + isArray: !0, + concatenateValues: !0, + properties: { + code: { + description: 'Code of the messages covered by this override', + type: T.STRING, + default: void 0, + }, + text: { + description: 'Code of the texts covered by this override', + type: T.STRING, + default: void 0, + }, + level: { + description: + 'Log level override, set to null to remove override', + type: T.STRING, + values: Object.values(N.LogLevel), + isNullable: !0, + default: void 0, + }, + }, + }, + enableTelemetry: { + description: + 'If true, telemetry will be periodically sent, following the rules in https://yarnpkg.com/advanced/telemetry', + type: T.BOOLEAN, + default: !0, + }, + telemetryInterval: { + description: + 'Minimal amount of time between two telemetry uploads, in days', + type: T.NUMBER, + default: 7, + }, + telemetryUserId: { + description: + 'If you desire to tell us which project you are, you can set this field. Completely optional and opt-in.', + type: T.STRING, + default: null, + }, + enableScripts: { + description: + 'If true, packages are allowed to have install scripts by default', + type: T.BOOLEAN, + default: !0, + }, + enableImmutableCache: { + description: + 'If true, the cache is reputed immutable and actions that would modify it will throw', + type: T.BOOLEAN, + default: !1, + }, + checksumBehavior: { + description: + "Enumeration defining what to do when a checksum doesn't match expectations", + type: T.STRING, + default: 'throw', + }, + packageExtensions: { + description: + 'Map of package corrections to apply on the dependency tree', + type: T.MAP, + valueDefinition: { + description: + 'The extension that will be applied to any package whose version matches the specified range', + type: T.SHAPE, + properties: { + dependencies: { + description: + 'The set of dependencies that must be made available to the current package in order for it to work properly', + type: T.MAP, + valueDefinition: { description: 'A range', type: T.STRING }, + }, + peerDependencies: { + description: + 'Inherited dependencies - the consumer of the package will be tasked to provide them', + type: T.MAP, + valueDefinition: { + description: 'A semver range', + type: T.STRING, + }, + }, + peerDependenciesMeta: { + description: + 'Extra information related to the dependencies listed in the peerDependencies field', + type: T.MAP, + valueDefinition: { + description: 'The peerDependency meta', + type: T.SHAPE, + properties: { + optional: { + description: + "If true, the selected peer dependency will be marked as optional by the package manager and the consumer omitting it won't be reported as an error", + type: T.BOOLEAN, + default: !1, + }, + }, + }, + }, + }, + }, + }, + }; + function G(e, t, r, A, n) { + if (A.isArray) + return Array.isArray(r) + ? r.map((r, o) => H(e, `${t}[${o}]`, r, A, n)) + : String(r) + .split(/,/) + .map((r) => H(e, t, r, A, n)); + if (Array.isArray(r)) + throw new Error( + `Non-array configuration settings "${t}" cannot be an array` + ); + return H(e, t, r, A, n); + } + function H(e, t, r, A, o) { + var i; + switch (A.type) { + case T.ANY: + return r; + case T.SHAPE: + return (function (e, t, r, A, n) { + if ('object' != typeof r || Array.isArray(r)) + throw new g.UsageError( + `Object configuration settings "${t}" must be an object` + ); + const o = J(e, A, { ignoreArrays: !0 }); + if (null === r) return o; + for (const [i, s] of Object.entries(r)) { + const r = `${t}.${i}`; + if (!A.properties[i]) + throw new g.UsageError( + `Unrecognized configuration settings found: ${t}.${i} - run "yarn config -v" to see the list of settings supported in Yarn` + ); + o.set(i, G(e, r, s, A.properties[i], n)); + } + return o; + })(e, t, r, A, o); + case T.MAP: + return (function (e, t, r, A, n) { + const o = new Map(); + if ('object' != typeof r || Array.isArray(r)) + throw new g.UsageError( + `Map configuration settings "${t}" must be an object` + ); + if (null === r) return o; + for (const [i, s] of Object.entries(r)) { + const r = A.normalizeKeys ? A.normalizeKeys(i) : i, + a = `${t}['${r}']`, + c = A.valueDefinition; + o.set(r, G(e, a, s, c, n)); + } + return o; + })(e, t, r, A, o); + } + if (null === r && !A.isNullable && null !== A.default) + throw new Error( + `Non-nullable configuration settings "${t}" cannot be set to null` + ); + if (null === (i = A.values) || void 0 === i ? void 0 : i.includes(r)) + return r; + const s = (() => { + if (A.type === T.BOOLEAN) return F.parseBoolean(r); + if ('string' != typeof r) + throw new Error(`Expected value (${r}) to be a string`); + const e = F.replaceEnvVariables(r, { env: process.env }); + switch (A.type) { + case T.ABSOLUTE_PATH: + return n.y1.resolve(o, n.cS.toPortablePath(e)); + case T.LOCATOR_LOOSE: + return f.parseLocator(e, !1); + case T.NUMBER: + return parseInt(e); + case T.LOCATOR: + return f.parseLocator(e); + default: + return e; + } + })(); + if (A.values && !A.values.includes(s)) + throw new Error( + 'Invalid value, expected one of ' + A.values.join(', ') + ); + return s; + } + function J(e, t, { ignoreArrays: r = !1 } = {}) { + switch (t.type) { + case T.SHAPE: { + if (t.isArray && !r) return []; + const A = new Map(); + for (const [r, n] of Object.entries(t.properties)) + A.set(r, J(e, n)); + return A; + } + case T.MAP: + return t.isArray && !r ? [] : new Map(); + case T.ABSOLUTE_PATH: + return null === t.default + ? null + : null === e.projectCwd + ? n.y1.isAbsolute(t.default) + ? n.y1.normalize(t.default) + : t.isNullable + ? null + : void 0 + : Array.isArray(t.default) + ? t.default.map((t) => n.y1.resolve(e.projectCwd, t)) + : n.y1.resolve(e.projectCwd, t.default); + default: + return t.default; + } + } + function q() { + for (const [e, t] of Object.entries(process.env)) + if ('yarn_rc_filename' === e.toLowerCase() && 'string' == typeof t) + return t; + return O; + } + var z; + !(function (e) { + (e[(e.LOCKFILE = 0)] = 'LOCKFILE'), + (e[(e.MANIFEST = 1)] = 'MANIFEST'), + (e[(e.NONE = 2)] = 'NONE'); + })(z || (z = {})); + class W { + constructor(e) { + (this.projectCwd = null), + (this.plugins = new Map()), + (this.settings = new Map()), + (this.values = new Map()), + (this.sources = new Map()), + (this.invalid = new Map()), + (this.packageExtensions = new Map()), + (this.limits = new Map()), + (this.startingCwd = e); + } + static create(e, t, r) { + const A = new W(e); + void 0 === t || t instanceof Map || (A.projectCwd = t), + A.importSettings(Y); + const n = void 0 !== r ? r : t instanceof Map ? t : new Map(); + for (const [e, t] of n) A.activatePlugin(e, t); + return A; + } + static async find( + e, + t, + { + lookup: r = z.LOCKFILE, + strict: o = !0, + usePath: i = !1, + useRc: s = !0, + } = {} + ) { + const c = (function () { + const e = {}; + for (let [t, r] of Object.entries(process.env)) + (t = t.toLowerCase()), + t.startsWith('yarn_') && + ((t = a()(t.slice('yarn_'.length))), (e[t] = r)); + return e; + })(); + delete c.rcFilename; + const l = await W.findRcFiles(e), + u = await W.findHomeRcFile(), + h = ({ + ignoreCwd: e, + yarnPath: t, + ignorePath: r, + lockfileFilename: A, + }) => ({ + ignoreCwd: e, + yarnPath: t, + ignorePath: r, + lockfileFilename: A, + }), + p = ({ + ignoreCwd: e, + yarnPath: t, + ignorePath: r, + lockfileFilename: A, + ...n + }) => n, + d = new W(e); + d.importSettings(h(Y)), + d.useWithSource('', h(c), e, { strict: !1 }); + for (const { path: e, cwd: t, data: r } of l) + d.useWithSource(e, h(r), t, { strict: !1 }); + if ( + (u && d.useWithSource(u.path, h(u.data), u.cwd, { strict: !1 }), + i) + ) { + const e = d.get('yarnPath'), + t = d.get('ignorePath'); + if (null !== e && !t) return d; + } + const C = d.get('lockfileFilename'); + let f; + switch (r) { + case z.LOCKFILE: + f = await W.findProjectCwd(e, C); + break; + case z.MANIFEST: + f = await W.findProjectCwd(e, null); + break; + case z.NONE: + f = A.xfs.existsSync(n.y1.join(e, 'package.json')) + ? n.y1.resolve(e) + : null; + } + (d.startingCwd = e), (d.projectCwd = f), d.importSettings(p(Y)); + const E = new Map([['@@core', I]]); + if (null !== t) { + for (const e of t.plugins.keys()) + E.set(e, (B = t.modules.get(e)).__esModule ? B.default : B); + const r = new Map(); + for (const e of new Set( + M().builtinModules || Object.keys(process.binding('natives')) + )) + r.set(e, () => R(e)); + for (const [e, A] of t.modules) r.set(e, () => A); + const A = new Set(), + o = (e) => e.default || e, + i = (e, t) => { + const { factory: i, name: s } = R(n.cS.fromPortablePath(e)); + if (A.has(s)) return; + const a = new Map(r), + c = (e) => { + if (a.has(e)) return a.get(e)(); + throw new g.UsageError( + `This plugin cannot access the package referenced via ${e} which is neither a builtin, nor an exposed entry` + ); + }, + l = F.prettifySyncErrors( + () => o(i(c)), + (e) => `${e} (when initializing ${s}, defined in ${t})` + ); + r.set(s, () => l), A.add(s), E.set(s, l); + }; + if (c.plugins) + for (const t of c.plugins.split(';')) { + i(n.y1.resolve(e, n.cS.toPortablePath(t)), ''); + } + for (const { path: e, cwd: t, data: r } of l) + if (s && Array.isArray(r.plugins)) + for (const A of r.plugins) { + const r = 'string' != typeof A ? A.path : A; + i(n.y1.resolve(t, n.cS.toPortablePath(r)), e); + } + } + var B; + for (const [e, t] of E) d.activatePlugin(e, t); + d.useWithSource('', p(c), e, { strict: o }); + for (const { path: e, cwd: t, data: r } of l) + d.useWithSource(e, p(r), t, { strict: o }); + return ( + u && d.useWithSource(u.path, p(u.data), u.cwd, { strict: !1 }), + d.get('enableGlobalCache') && + (d.values.set('cacheFolder', d.get('globalFolder') + '/cache'), + d.sources.set('cacheFolder', '')), + await d.refreshPackageExtensions(), + d + ); + } + static async findRcFiles(e) { + const t = q(), + r = []; + let o = e, + s = null; + for (; o !== s; ) { + s = o; + const e = n.y1.join(s, t); + if (A.xfs.existsSync(e)) { + const t = await A.xfs.readFilePromise(e, 'utf8'); + let n; + try { + n = (0, i.parseSyml)(t); + } catch (r) { + let A = ''; + throw ( + (t.match(/^\s+(?!-)[^:]+\s+\S+/m) && + (A = + ' (in particular, make sure you list the colons after each key name)'), + new g.UsageError( + `Parse error when loading ${e}; please check it's proper Yaml${A}` + )) + ); + } + r.push({ path: e, cwd: s, data: n }); + } + o = n.y1.dirname(s); + } + return r; + } + static async findHomeRcFile() { + const e = q(), + t = k.getHomeFolder(), + r = n.y1.join(t, e); + if (A.xfs.existsSync(r)) { + const e = await A.xfs.readFilePromise(r, 'utf8'); + return { path: r, cwd: t, data: (0, i.parseSyml)(e) }; + } + return null; + } + static async findProjectCwd(e, t) { + let r = null, + o = e, + i = null; + for (; o !== i; ) { + if ( + ((i = o), + A.xfs.existsSync(n.y1.join(i, 'package.json')) && (r = i), + null !== t) + ) { + if (A.xfs.existsSync(n.y1.join(i, t))) { + r = i; + break; + } + } else if (null !== r) break; + o = n.y1.dirname(i); + } + return r; + } + static async updateConfiguration(e, t) { + const r = q(), + o = n.y1.join(e, r), + s = A.xfs.existsSync(o) + ? (0, i.parseSyml)(await A.xfs.readFilePromise(o, 'utf8')) + : {}; + let a, + c = !1; + if ('function' == typeof t) { + try { + a = t(s); + } catch (e) { + a = t({}); + } + if (a === s) return; + } else { + a = s; + for (const e of Object.keys(t)) { + const r = s[e], + A = t[e]; + let n; + if ('function' == typeof A) + try { + n = A(r); + } catch (e) { + n = A(void 0); + } + else n = A; + r !== n && ((a[e] = n), (c = !0)); + } + if (!c) return; + } + await A.xfs.changeFilePromise(o, (0, i.stringifySyml)(a), { + automaticNewlines: !0, + }); + } + static async updateHomeConfiguration(e) { + const t = k.getHomeFolder(); + return await W.updateConfiguration(t, e); + } + activatePlugin(e, t) { + this.plugins.set(e, t), + void 0 !== t.configuration && + this.importSettings(t.configuration); + } + importSettings(e) { + for (const [t, r] of Object.entries(e)) + if (null != r) { + if (this.settings.has(t)) + throw new Error(`Cannot redefine settings "${t}"`); + this.settings.set(t, r), this.values.set(t, J(this, r)); + } + } + useWithSource(e, t, r, A) { + try { + this.use(e, t, r, A); + } catch (t) { + throw ( + ((t.message += ` (in ${N.pretty(this, e, N.Type.PATH)})`), t) + ); + } + } + use(e, t, r, { strict: A = !0, overwrite: n = !1 } = {}) { + for (const o of Object.keys(t)) { + if (void 0 === t[o]) continue; + if ('plugins' === o) continue; + if ('' === e && P.has(o)) continue; + if ('rcFilename' === o) + throw new g.UsageError( + `The rcFilename settings can only be set via ${'yarn_RC_FILENAME'.toUpperCase()}, not via a rc file` + ); + const i = this.settings.get(o); + if (!i) { + if (A) + throw new g.UsageError( + `Unrecognized or legacy configuration settings found: ${o} - run "yarn config -v" to see the list of settings supported in Yarn` + ); + this.invalid.set(o, e); + continue; + } + if ( + this.sources.has(o) && + !(n || i.type === T.MAP || (i.isArray && i.concatenateValues)) + ) + continue; + let s; + try { + s = G(this, o, t[o], i, r); + } catch (t) { + throw ( + ((t.message += ' in ' + N.pretty(this, e, N.Type.PATH)), t) + ); + } + if (i.type === T.MAP) { + const t = this.values.get(o); + this.values.set(o, new Map(n ? [...t, ...s] : [...s, ...t])), + this.sources.set(o, `${this.sources.get(o)}, ${e}`); + } else if (i.isArray && i.concatenateValues) { + const t = this.values.get(o); + this.values.set(o, n ? [...t, ...s] : [...s, ...t]), + this.sources.set(o, `${this.sources.get(o)}, ${e}`); + } else this.values.set(o, s), this.sources.set(o, e); + } + } + get(e) { + if (!this.values.has(e)) + throw new Error(`Invalid configuration key "${e}"`); + return this.values.get(e); + } + getSpecial(e, { hideSecrets: t = !1, getNativePaths: r = !1 }) { + const A = this.get(e), + o = this.settings.get(e); + if (void 0 === o) + throw new g.UsageError( + `Couldn't find a configuration settings named "${e}"` + ); + return (function e(t, r, A) { + if (r.type === T.SECRET && 'string' == typeof t && A.hideSecrets) + return '********'; + if ( + r.type === T.ABSOLUTE_PATH && + 'string' == typeof t && + A.getNativePaths + ) + return n.cS.fromPortablePath(t); + if (r.isArray && Array.isArray(t)) { + const n = []; + for (const o of t) n.push(e(o, r, A)); + return n; + } + if (r.type === T.MAP && t instanceof Map) { + const n = new Map(); + for (const [o, i] of t.entries()) + n.set(o, e(i, r.valueDefinition, A)); + return n; + } + if (r.type === T.SHAPE && t instanceof Map) { + const n = new Map(); + for (const [o, i] of t.entries()) { + const t = r.properties[o]; + n.set(o, e(i, t, A)); + } + return n; + } + return t; + })(A, o, { hideSecrets: t, getNativePaths: r }); + } + getSubprocessStreams(e, { header: t, prefix: r, report: n }) { + let o, i; + const s = A.xfs.createWriteStream(e); + if (this.get('enableInlineBuilds')) { + const e = n.createStreamReporter( + `${r} ${N.pretty(this, 'STDOUT', 'green')}` + ), + t = n.createStreamReporter( + `${r} ${N.pretty(this, 'STDERR', 'red')}` + ); + (o = new d.PassThrough()), + o.pipe(e), + o.pipe(s), + (i = new d.PassThrough()), + i.pipe(t), + i.pipe(s); + } else (o = s), (i = s), void 0 !== t && o.write(t + '\n'); + return { stdout: o, stderr: i }; + } + makeResolver() { + const e = []; + for (const t of this.plugins.values()) + for (const r of t.resolvers || []) e.push(new r()); + return new m.B([new D(), new v.d(), new w.O(), ...e]); + } + makeFetcher() { + const e = []; + for (const t of this.plugins.values()) + for (const r of t.fetchers || []) e.push(new r()); + return new y([new Q.N(), new S(), ...e]); + } + getLinkers() { + const e = []; + for (const t of this.plugins.values()) + for (const r of t.linkers || []) e.push(new r()); + return e; + } + async refreshPackageExtensions() { + this.packageExtensions = new Map(); + const e = this.packageExtensions, + t = (t, r, { userProvided: A = !1 } = {}) => { + if (!p().validRange(t.range)) + throw new Error( + 'Only semver ranges are allowed as keys for the lockfileExtensions setting' + ); + const n = new E.G(); + n.load(r, { yamlCompatibilityMode: !0 }); + const o = []; + F.getArrayWithDefault(e, t.identHash).push([t.range, o]); + const i = { + status: L._u.Inactive, + userProvided: A, + parentDescriptor: t, + }; + for (const e of n.dependencies.values()) + o.push({ + ...i, + type: L.HN.Dependency, + descriptor: e, + description: `${f.stringifyIdent(t)} > ${f.stringifyIdent( + e + )}`, + }); + for (const e of n.peerDependencies.values()) + o.push({ + ...i, + type: L.HN.PeerDependency, + descriptor: e, + description: `${f.stringifyIdent(t)} >> ${f.stringifyIdent( + e + )}`, + }); + for (const [e, r] of n.peerDependenciesMeta) + for (const [A, n] of Object.entries(r)) + o.push({ + ...i, + type: L.HN.PeerDependencyMeta, + selector: e, + key: A, + value: n, + description: `${f.stringifyIdent(t)} >> ${e} / ${A}`, + }); + }; + await this.triggerHook((e) => e.registerPackageExtensions, this, t); + for (const [e, r] of this.get('packageExtensions')) + t(f.parseDescriptor(e, !0), F.convertMapsToIndexableObjects(r), { + userProvided: !0, + }); + } + normalizePackage(e) { + const t = f.copyPackage(e); + if (null == this.packageExtensions) + throw new Error( + 'refreshPackageExtensions has to be called before normalizing packages' + ); + const r = this.packageExtensions.get(e.identHash); + if (void 0 !== r) { + const A = e.version; + if (null !== A) + for (const [e, n] of r) + if (x.satisfiesWithPrereleases(A, e)) + for (const e of n) + switch ( + (e.status === L._u.Inactive && + (e.status = L._u.Redundant), + e.type) + ) { + case L.HN.Dependency: + void 0 === + t.dependencies.get(e.descriptor.identHash) && + ((e.status = L._u.Active), + t.dependencies.set( + e.descriptor.identHash, + e.descriptor + )); + break; + case L.HN.PeerDependency: + void 0 === + t.peerDependencies.get(e.descriptor.identHash) && + ((e.status = L._u.Active), + t.peerDependencies.set( + e.descriptor.identHash, + e.descriptor + )); + break; + case L.HN.PeerDependencyMeta: + { + const r = t.peerDependenciesMeta.get(e.selector); + (void 0 !== r && + Object.prototype.hasOwnProperty.call(r, e.key) && + r[e.key] === e.value) || + ((e.status = L._u.Active), + (F.getFactoryWithDefault( + t.peerDependenciesMeta, + e.selector, + () => ({}) + )[e.key] = e.value)); + } + break; + default: + F.assertNever(e); + } + } + const A = (e) => (e.scope ? `${e.scope}__${e.name}` : '' + e.name); + for (const e of t.peerDependencies.values()) { + if ('@types' === e.scope) continue; + const r = A(e), + n = f.makeIdent('types', r); + t.peerDependencies.has(n.identHash) || + t.peerDependenciesMeta.has(n.identHash) || + t.peerDependenciesMeta.set(f.stringifyIdent(n), { + optional: !0, + }); + } + for (const e of t.peerDependenciesMeta.keys()) { + const r = f.parseIdent(e); + t.peerDependencies.has(r.identHash) || + t.peerDependencies.set(r.identHash, f.makeDescriptor(r, '*')); + } + return ( + (t.dependencies = new Map( + F.sortMap(t.dependencies, ([, e]) => f.stringifyDescriptor(e)) + )), + (t.peerDependencies = new Map( + F.sortMap(t.peerDependencies, ([, e]) => + f.stringifyDescriptor(e) + ) + )), + t + ); + } + getLimit(e) { + return F.getFactoryWithDefault(this.limits, e, () => + u()(this.get(e)) + ); + } + async triggerHook(e, ...t) { + for (const r of this.plugins.values()) { + const A = r.hooks; + if (!A) continue; + const n = e(A); + n && (await n(...t)); + } + } + async triggerMultipleHooks(e, t) { + for (const r of t) await this.triggerHook(e, ...r); + } + async reduceHook(e, t, ...r) { + let A = t; + for (const t of this.plugins.values()) { + const n = t.hooks; + if (!n) continue; + const o = e(n); + o && (A = await o(A, ...r)); + } + return A; + } + async firstHook(e, ...t) { + for (const r of this.plugins.values()) { + const A = r.hooks; + if (!A) continue; + const n = e(A); + if (!n) continue; + const o = await n(...t); + if (void 0 !== o) return o; + } + return null; + } + format(e, t) { + return N.pretty(this, e, t); + } + } + W.telemetry = null; + }, + 92409: (e, t, r) => { + 'use strict'; + var A; + r.d(t, { k: () => A }), + (function (e) { + (e[(e.SCRIPT = 0)] = 'SCRIPT'), + (e[(e.SHELLCODE = 1)] = 'SHELLCODE'); + })(A || (A = {})); + }, + 62152: (e, t, r) => { + 'use strict'; + r.d(t, { h: () => i }); + var A = r(35691), + n = r(15815), + o = r(71643); + class i extends A.yG { + constructor({ configuration: e, stdout: t, suggestInstall: r = !0 }) { + super(), + (this.errorCount = 0), + o.addLogFilterSupport(this, { configuration: e }), + (this.configuration = e), + (this.stdout = t), + (this.suggestInstall = r); + } + static async start(e, t) { + const r = new this(e); + try { + await t(r); + } catch (e) { + r.reportExceptionOnce(e); + } finally { + await r.finalize(); + } + return r; + } + hasErrors() { + return this.errorCount > 0; + } + exitCode() { + return this.hasErrors() ? 1 : 0; + } + reportCacheHit(e) {} + reportCacheMiss(e) {} + startTimerSync(e, t, r) { + return ('function' == typeof t ? t : r)(); + } + async startTimerPromise(e, t, r) { + const A = 'function' == typeof t ? t : r; + return await A(); + } + async startCacheReport(e) { + return await e(); + } + reportSeparator() {} + reportInfo(e, t) {} + reportWarning(e, t) {} + reportError(e, t) { + (this.errorCount += 1), + this.stdout.write( + `${o.pretty( + this.configuration, + '➤', + 'redBright' + )} ${this.formatNameWithHyperlink(e)}: ${t}\n` + ); + } + reportProgress(e) { + return { + ...Promise.resolve().then(async () => { + for await (const {} of e); + }), + stop: () => {}, + }; + } + reportJson(e) {} + async finalize() { + this.errorCount > 0 && + (this.stdout.write( + o.pretty(this.configuration, '➤', 'redBright') + + ' Errors happened when preparing the environment required to run this command.\n' + ), + this.suggestInstall && + this.stdout.write( + o.pretty(this.configuration, '➤', 'redBright') + + ' This might be caused by packages being missing from the lockfile, in which case running "yarn install" might help.\n' + )); + } + formatNameWithHyperlink(e) { + return (0, n.Qw)(e, { + configuration: this.configuration, + json: !1, + }); + } + } + }, + 46611: (e, t, r) => { + 'use strict'; + r.d(t, { G: () => l }); + var A = r(78420), + n = r(46009), + o = r(11640), + i = r(53887), + s = r.n(i), + a = r(73632), + c = r(36545), + g = r(54143); + class l { + constructor() { + (this.indent = ' '), + (this.name = null), + (this.version = null), + (this.os = null), + (this.cpu = null), + (this.type = null), + (this.private = !1), + (this.license = null), + (this.main = null), + (this.module = null), + (this.browser = null), + (this.languageName = null), + (this.bin = new Map()), + (this.scripts = new Map()), + (this.dependencies = new Map()), + (this.devDependencies = new Map()), + (this.peerDependencies = new Map()), + (this.workspaceDefinitions = []), + (this.dependenciesMeta = new Map()), + (this.peerDependenciesMeta = new Map()), + (this.resolutions = []), + (this.files = null), + (this.publishConfig = null), + (this.installConfig = null), + (this.preferUnplugged = null), + (this.raw = {}), + (this.errors = []); + } + static async tryFind(e, { baseFs: t = new A.S() } = {}) { + const r = n.y1.join(e, 'package.json'); + return (await t.existsPromise(r)) + ? await l.fromFile(r, { baseFs: t }) + : null; + } + static async find(e, { baseFs: t } = {}) { + const r = await l.tryFind(e, { baseFs: t }); + if (null === r) throw new Error('Manifest not found'); + return r; + } + static async fromFile(e, { baseFs: t = new A.S() } = {}) { + const r = new l(); + return await r.loadFile(e, { baseFs: t }), r; + } + static fromText(e) { + const t = new l(); + return t.loadFromText(e), t; + } + static isManifestFieldCompatible(e, t) { + if (null === e) return !0; + let r = !0, + A = !1; + for (const n of e) + if ('!' === n[0]) { + if (((A = !0), t === n.slice(1))) return !1; + } else if (((r = !1), n === t)) return !0; + return A && r; + } + loadFromText(e) { + let t; + try { + t = JSON.parse(h(e) || '{}'); + } catch (t) { + throw ((t.message += ` (when parsing ${e})`), t); + } + this.load(t), (this.indent = u(e)); + } + async loadFile(e, { baseFs: t = new A.S() }) { + const r = await t.readFilePromise(e, 'utf8'); + let n; + try { + n = JSON.parse(h(r) || '{}'); + } catch (t) { + throw ((t.message += ` (when parsing ${e})`), t); + } + this.load(n), (this.indent = u(r)); + } + load(e, { yamlCompatibilityMode: t = !1 } = {}) { + if ('object' != typeof e || null === e) + throw new Error(`Utterly invalid manifest data (${e})`); + this.raw = e; + const r = []; + if ('string' == typeof e.name) + try { + this.name = g.parseIdent(e.name); + } catch (e) { + r.push(new Error("Parsing failed for the 'name' field")); + } + if ( + ('string' == typeof e.version && (this.version = e.version), + Array.isArray(e.os)) + ) { + const t = []; + this.os = t; + for (const A of e.os) + 'string' != typeof A + ? r.push(new Error("Parsing failed for the 'os' field")) + : t.push(A); + } + if (Array.isArray(e.cpu)) { + const t = []; + this.cpu = t; + for (const A of e.cpu) + 'string' != typeof A + ? r.push(new Error("Parsing failed for the 'cpu' field")) + : t.push(A); + } + if ( + ('string' == typeof e.type && (this.type = e.type), + 'boolean' == typeof e.private && (this.private = e.private), + 'string' == typeof e.license && (this.license = e.license), + 'string' == typeof e.languageName && + (this.languageName = e.languageName), + 'string' == typeof e.main && (this.main = p(e.main)), + 'string' == typeof e.module && (this.module = p(e.module)), + null != e.browser) + ) + if ('string' == typeof e.browser) this.browser = p(e.browser); + else { + this.browser = new Map(); + for (const [t, r] of Object.entries(e.browser)) + this.browser.set(p(t), 'string' == typeof r ? p(r) : r); + } + if ('string' == typeof e.bin) + null !== this.name + ? (this.bin = new Map([[this.name.name, p(e.bin)]])) + : r.push( + new Error('String bin field, but no attached package name') + ); + else if ('object' == typeof e.bin && null !== e.bin) + for (const [t, A] of Object.entries(e.bin)) + 'string' == typeof A + ? this.bin.set(t, p(A)) + : r.push(new Error(`Invalid bin definition for '${t}'`)); + if ('object' == typeof e.scripts && null !== e.scripts) + for (const [t, A] of Object.entries(e.scripts)) + 'string' == typeof A + ? this.scripts.set(t, A) + : r.push(new Error(`Invalid script definition for '${t}'`)); + if ('object' == typeof e.dependencies && null !== e.dependencies) + for (const [t, A] of Object.entries(e.dependencies)) { + if ('string' != typeof A) { + r.push(new Error(`Invalid dependency range for '${t}'`)); + continue; + } + let e; + try { + e = g.parseIdent(t); + } catch (e) { + r.push( + new Error(`Parsing failed for the dependency name '${t}'`) + ); + continue; + } + const n = g.makeDescriptor(e, A); + this.dependencies.set(n.identHash, n); + } + if ( + 'object' == typeof e.devDependencies && + null !== e.devDependencies + ) + for (const [t, A] of Object.entries(e.devDependencies)) { + if ('string' != typeof A) { + r.push(new Error(`Invalid dependency range for '${t}'`)); + continue; + } + let e; + try { + e = g.parseIdent(t); + } catch (e) { + r.push( + new Error(`Parsing failed for the dependency name '${t}'`) + ); + continue; + } + const n = g.makeDescriptor(e, A); + this.devDependencies.set(n.identHash, n); + } + if ( + 'object' == typeof e.peerDependencies && + null !== e.peerDependencies + ) + for (let [t, A] of Object.entries(e.peerDependencies)) { + let e; + try { + e = g.parseIdent(t); + } catch (e) { + r.push( + new Error(`Parsing failed for the dependency name '${t}'`) + ); + continue; + } + ('string' == typeof A && c.validRange(A)) || + (r.push(new Error(`Invalid dependency range for '${t}'`)), + (A = '*')); + const n = g.makeDescriptor(e, A); + this.peerDependencies.set(n.identHash, n); + } + 'object' == typeof e.workspaces && + e.workspaces.nohoist && + r.push( + new Error( + "'nohoist' is deprecated, please use 'installConfig.hoistingLimits' instead" + ) + ); + const A = Array.isArray(e.workspaces) + ? e.workspaces + : 'object' == typeof e.workspaces && + null !== e.workspaces && + Array.isArray(e.workspaces.packages) + ? e.workspaces.packages + : []; + for (const e of A) + 'string' == typeof e + ? this.workspaceDefinitions.push({ pattern: e }) + : r.push(new Error(`Invalid workspace definition for '${e}'`)); + if ( + 'object' == typeof e.dependenciesMeta && + null !== e.dependenciesMeta + ) + for (const [A, n] of Object.entries(e.dependenciesMeta)) { + if ('object' != typeof n || null === n) { + r.push(new Error("Invalid meta field for '" + A)); + continue; + } + const e = g.parseDescriptor(A), + o = this.ensureDependencyMeta(e), + i = d(n.built, { yamlCompatibilityMode: t }); + if (null === i) { + r.push(new Error(`Invalid built meta field for '${A}'`)); + continue; + } + const s = d(n.optional, { yamlCompatibilityMode: t }); + if (null === s) { + r.push(new Error(`Invalid optional meta field for '${A}'`)); + continue; + } + const a = d(n.unplugged, { yamlCompatibilityMode: t }); + null !== a + ? Object.assign(o, { built: i, optional: s, unplugged: a }) + : r.push( + new Error(`Invalid unplugged meta field for '${A}'`) + ); + } + if ( + 'object' == typeof e.peerDependenciesMeta && + null !== e.peerDependenciesMeta + ) + for (const [A, n] of Object.entries(e.peerDependenciesMeta)) { + if ('object' != typeof n || null === n) { + r.push(new Error(`Invalid meta field for '${A}'`)); + continue; + } + const e = g.parseDescriptor(A), + o = this.ensurePeerDependencyMeta(e), + i = d(n.optional, { yamlCompatibilityMode: t }); + null !== i + ? Object.assign(o, { optional: i }) + : r.push(new Error(`Invalid optional meta field for '${A}'`)); + } + if ('object' == typeof e.resolutions && null !== e.resolutions) + for (const [t, A] of Object.entries(e.resolutions)) + if ('string' == typeof A) + try { + this.resolutions.push({ + pattern: (0, o.parseResolution)(t), + reference: A, + }); + } catch (e) { + r.push(e); + continue; + } + else r.push(new Error(`Invalid resolution entry for '${t}'`)); + if (Array.isArray(e.files)) { + this.files = new Set(); + for (const t of e.files) + 'string' == typeof t + ? this.files.add(t) + : r.push(new Error(`Invalid files entry for '${t}'`)); + } + if ( + 'object' == typeof e.publishConfig && + null !== e.publishConfig + ) { + if ( + ((this.publishConfig = {}), + 'string' == typeof e.publishConfig.access && + (this.publishConfig.access = e.publishConfig.access), + 'string' == typeof e.publishConfig.main && + (this.publishConfig.main = p(e.publishConfig.main)), + 'string' == typeof e.publishConfig.module && + (this.publishConfig.module = p(e.publishConfig.module)), + null != e.publishConfig.browser) + ) + if ('string' == typeof e.publishConfig.browser) + this.publishConfig.browser = p(e.publishConfig.browser); + else { + this.publishConfig.browser = new Map(); + for (const [t, r] of Object.entries(e.publishConfig.browser)) + this.publishConfig.browser.set( + p(t), + 'string' == typeof r ? p(r) : r + ); + } + if ( + ('string' == typeof e.publishConfig.registry && + (this.publishConfig.registry = e.publishConfig.registry), + 'string' == typeof e.publishConfig.bin) + ) + null !== this.name + ? (this.publishConfig.bin = new Map([ + [this.name.name, p(e.publishConfig.bin)], + ])) + : r.push( + new Error( + 'String bin field, but no attached package name' + ) + ); + else if ( + 'object' == typeof e.publishConfig.bin && + null !== e.publishConfig.bin + ) { + this.publishConfig.bin = new Map(); + for (const [t, A] of Object.entries(e.publishConfig.bin)) + 'string' == typeof A + ? this.publishConfig.bin.set(t, p(A)) + : r.push(new Error(`Invalid bin definition for '${t}'`)); + } + if (Array.isArray(e.publishConfig.executableFiles)) { + this.publishConfig.executableFiles = new Set(); + for (const t of e.publishConfig.executableFiles) + 'string' == typeof t + ? this.publishConfig.executableFiles.add(p(t)) + : r.push(new Error('Invalid executable file definition')); + } + } + if ( + 'object' == typeof e.installConfig && + null !== e.installConfig + ) { + this.installConfig = {}; + for (const t of Object.keys(e.installConfig)) + 'hoistingLimits' === t + ? 'string' == typeof e.installConfig.hoistingLimits + ? (this.installConfig.hoistingLimits = + e.installConfig.hoistingLimits) + : r.push(new Error('Invalid hoisting limits definition')) + : r.push(new Error('Unrecognized installConfig key: ' + t)); + } + if ( + 'object' == typeof e.optionalDependencies && + null !== e.optionalDependencies + ) + for (const [t, A] of Object.entries(e.optionalDependencies)) { + if ('string' != typeof A) { + r.push(new Error(`Invalid dependency range for '${t}'`)); + continue; + } + let e; + try { + e = g.parseIdent(t); + } catch (e) { + r.push( + new Error(`Parsing failed for the dependency name '${t}'`) + ); + continue; + } + const n = g.makeDescriptor(e, A); + this.dependencies.set(n.identHash, n); + const o = g.makeDescriptor(e, 'unknown'), + i = this.ensureDependencyMeta(o); + Object.assign(i, { optional: !0 }); + } + 'boolean' == typeof e.preferUnplugged && + (this.preferUnplugged = e.preferUnplugged), + (this.errors = r); + } + getForScope(e) { + switch (e) { + case 'dependencies': + return this.dependencies; + case 'devDependencies': + return this.devDependencies; + case 'peerDependencies': + return this.peerDependencies; + default: + throw new Error(`Unsupported value ("${e}")`); + } + } + hasConsumerDependency(e) { + return ( + !!this.dependencies.has(e.identHash) || + !!this.peerDependencies.has(e.identHash) + ); + } + hasHardDependency(e) { + return ( + !!this.dependencies.has(e.identHash) || + !!this.devDependencies.has(e.identHash) + ); + } + hasSoftDependency(e) { + return !!this.peerDependencies.has(e.identHash); + } + hasDependency(e) { + return !!this.hasHardDependency(e) || !!this.hasSoftDependency(e); + } + isCompatibleWithOS(e) { + return l.isManifestFieldCompatible(this.os, e); + } + isCompatibleWithCPU(e) { + return l.isManifestFieldCompatible(this.cpu, e); + } + ensureDependencyMeta(e) { + if ('unknown' !== e.range && !s().valid(e.range)) + throw new Error( + `Invalid meta field range for '${g.stringifyDescriptor(e)}'` + ); + const t = g.stringifyIdent(e), + r = 'unknown' !== e.range ? e.range : null; + let A = this.dependenciesMeta.get(t); + A || this.dependenciesMeta.set(t, (A = new Map())); + let n = A.get(r); + return n || A.set(r, (n = {})), n; + } + ensurePeerDependencyMeta(e) { + if ('unknown' !== e.range) + throw new Error( + `Invalid meta field range for '${g.stringifyDescriptor(e)}'` + ); + const t = g.stringifyIdent(e); + let r = this.peerDependenciesMeta.get(t); + return r || this.peerDependenciesMeta.set(t, (r = {})), r; + } + setRawField(e, t, { after: r = [] } = {}) { + const A = new Set( + r.filter((e) => Object.prototype.hasOwnProperty.call(this.raw, e)) + ); + if ( + 0 === A.size || + Object.prototype.hasOwnProperty.call(this.raw, e) + ) + this.raw[e] = t; + else { + const r = this.raw, + n = (this.raw = {}); + let o = !1; + for (const i of Object.keys(r)) + (n[i] = r[i]), + o || (A.delete(i), 0 === A.size && ((n[e] = t), (o = !0))); + } + } + exportTo(e, { compatibilityMode: t = !0 } = {}) { + if ( + (Object.assign(e, this.raw), + null !== this.name + ? (e.name = g.stringifyIdent(this.name)) + : delete e.name, + null !== this.version + ? (e.version = this.version) + : delete e.version, + null !== this.os ? (e.os = this.os) : delete e.os, + null !== this.cpu ? (e.cpu = this.cpu) : delete e.cpu, + null !== this.type ? (e.type = this.type) : delete e.type, + this.private ? (e.private = !0) : delete e.private, + null !== this.license + ? (e.license = this.license) + : delete e.license, + null !== this.languageName + ? (e.languageName = this.languageName) + : delete e.languageName, + null !== this.main ? (e.main = this.main) : delete e.main, + null !== this.module ? (e.module = this.module) : delete e.module, + null !== this.browser) + ) { + const t = this.browser; + 'string' == typeof t + ? (e.browser = t) + : t instanceof Map && + (e.browser = Object.assign( + {}, + ...Array.from(t.keys()) + .sort() + .map((e) => ({ [e]: t.get(e) })) + )); + } else delete e.browser; + 1 === this.bin.size && + null !== this.name && + this.bin.has(this.name.name) + ? (e.bin = this.bin.get(this.name.name)) + : this.bin.size > 0 + ? (e.bin = Object.assign( + {}, + ...Array.from(this.bin.keys()) + .sort() + .map((e) => ({ [e]: this.bin.get(e) })) + )) + : delete e.bin, + this.workspaceDefinitions.length > 0 + ? this.raw.workspaces && !Array.isArray(this.raw.workspaces) + ? (e.workspaces = { + ...this.raw.workspaces, + packages: this.workspaceDefinitions.map( + ({ pattern: e }) => e + ), + }) + : (e.workspaces = this.workspaceDefinitions.map( + ({ pattern: e }) => e + )) + : this.raw.workspaces && + !Array.isArray(this.raw.workspaces) && + Object.keys(this.raw.workspaces).length > 0 + ? (e.workspaces = this.raw.workspaces) + : delete e.workspaces; + const r = [], + A = []; + for (const e of this.dependencies.values()) { + const n = this.dependenciesMeta.get(g.stringifyIdent(e)); + let o = !1; + if (t && n) { + const e = n.get(null); + e && e.optional && (o = !0); + } + o ? A.push(e) : r.push(e); + } + r.length > 0 + ? (e.dependencies = Object.assign( + {}, + ...g + .sortDescriptors(r) + .map((e) => ({ [g.stringifyIdent(e)]: e.range })) + )) + : delete e.dependencies, + A.length > 0 + ? (e.optionalDependencies = Object.assign( + {}, + ...g + .sortDescriptors(A) + .map((e) => ({ [g.stringifyIdent(e)]: e.range })) + )) + : delete e.optionalDependencies, + this.devDependencies.size > 0 + ? (e.devDependencies = Object.assign( + {}, + ...g + .sortDescriptors(this.devDependencies.values()) + .map((e) => ({ [g.stringifyIdent(e)]: e.range })) + )) + : delete e.devDependencies, + this.peerDependencies.size > 0 + ? (e.peerDependencies = Object.assign( + {}, + ...g + .sortDescriptors(this.peerDependencies.values()) + .map((e) => ({ [g.stringifyIdent(e)]: e.range })) + )) + : delete e.peerDependencies, + (e.dependenciesMeta = {}); + for (const [r, A] of a.sortMap( + this.dependenciesMeta.entries(), + ([e, t]) => e + )) + for (const [n, o] of a.sortMap(A.entries(), ([e, t]) => + null !== e ? '0' + e : '1' + )) { + const A = + null !== n + ? g.stringifyDescriptor( + g.makeDescriptor(g.parseIdent(r), n) + ) + : r, + i = { ...o }; + t && null === n && delete i.optional, + 0 !== Object.keys(i).length && (e.dependenciesMeta[A] = i); + } + return ( + 0 === Object.keys(e.dependenciesMeta).length && + delete e.dependenciesMeta, + this.peerDependenciesMeta.size > 0 + ? (e.peerDependenciesMeta = Object.assign( + {}, + ...a + .sortMap( + this.peerDependenciesMeta.entries(), + ([e, t]) => e + ) + .map(([e, t]) => ({ [e]: t })) + )) + : delete e.peerDependenciesMeta, + this.resolutions.length > 0 + ? (e.resolutions = Object.assign( + {}, + ...this.resolutions.map(({ pattern: e, reference: t }) => ({ + [(0, o.stringifyResolution)(e)]: t, + })) + )) + : delete e.resolutions, + null !== this.files + ? (e.files = Array.from(this.files)) + : delete e.files, + null !== this.preferUnplugged + ? (e.preferUnplugged = this.preferUnplugged) + : delete e.preferUnplugged, + e + ); + } + } + function u(e) { + const t = e.match(/^[ \t]+/m); + return t ? t[0] : ' '; + } + function h(e) { + return 65279 === e.charCodeAt(0) ? e.slice(1) : e; + } + function p(e) { + return e.replace(/\\/g, '/'); + } + function d(e, { yamlCompatibilityMode: t }) { + return t + ? a.tryParseOptionalBoolean(e) + : void 0 === e || 'boolean' == typeof e + ? e + : null; + } + (l.fileName = 'package.json'), + (l.allDependencies = [ + 'dependencies', + 'devDependencies', + 'peerDependencies', + ]), + (l.hardDependencies = ['dependencies', 'devDependencies']); + }, + 92659: (e, t, r) => { + 'use strict'; + var A; + function n(e) { + return 'YN' + e.toString(10).padStart(4, '0'); + } + r.d(t, { b: () => A, i: () => n }), + (function (e) { + (e[(e.UNNAMED = 0)] = 'UNNAMED'), + (e[(e.EXCEPTION = 1)] = 'EXCEPTION'), + (e[(e.MISSING_PEER_DEPENDENCY = 2)] = 'MISSING_PEER_DEPENDENCY'), + (e[(e.CYCLIC_DEPENDENCIES = 3)] = 'CYCLIC_DEPENDENCIES'), + (e[(e.DISABLED_BUILD_SCRIPTS = 4)] = 'DISABLED_BUILD_SCRIPTS'), + (e[(e.BUILD_DISABLED = 5)] = 'BUILD_DISABLED'), + (e[(e.SOFT_LINK_BUILD = 6)] = 'SOFT_LINK_BUILD'), + (e[(e.MUST_BUILD = 7)] = 'MUST_BUILD'), + (e[(e.MUST_REBUILD = 8)] = 'MUST_REBUILD'), + (e[(e.BUILD_FAILED = 9)] = 'BUILD_FAILED'), + (e[(e.RESOLVER_NOT_FOUND = 10)] = 'RESOLVER_NOT_FOUND'), + (e[(e.FETCHER_NOT_FOUND = 11)] = 'FETCHER_NOT_FOUND'), + (e[(e.LINKER_NOT_FOUND = 12)] = 'LINKER_NOT_FOUND'), + (e[(e.FETCH_NOT_CACHED = 13)] = 'FETCH_NOT_CACHED'), + (e[(e.YARN_IMPORT_FAILED = 14)] = 'YARN_IMPORT_FAILED'), + (e[(e.REMOTE_INVALID = 15)] = 'REMOTE_INVALID'), + (e[(e.REMOTE_NOT_FOUND = 16)] = 'REMOTE_NOT_FOUND'), + (e[(e.RESOLUTION_PACK = 17)] = 'RESOLUTION_PACK'), + (e[(e.CACHE_CHECKSUM_MISMATCH = 18)] = 'CACHE_CHECKSUM_MISMATCH'), + (e[(e.UNUSED_CACHE_ENTRY = 19)] = 'UNUSED_CACHE_ENTRY'), + (e[(e.MISSING_LOCKFILE_ENTRY = 20)] = 'MISSING_LOCKFILE_ENTRY'), + (e[(e.WORKSPACE_NOT_FOUND = 21)] = 'WORKSPACE_NOT_FOUND'), + (e[(e.TOO_MANY_MATCHING_WORKSPACES = 22)] = + 'TOO_MANY_MATCHING_WORKSPACES'), + (e[(e.CONSTRAINTS_MISSING_DEPENDENCY = 23)] = + 'CONSTRAINTS_MISSING_DEPENDENCY'), + (e[(e.CONSTRAINTS_INCOMPATIBLE_DEPENDENCY = 24)] = + 'CONSTRAINTS_INCOMPATIBLE_DEPENDENCY'), + (e[(e.CONSTRAINTS_EXTRANEOUS_DEPENDENCY = 25)] = + 'CONSTRAINTS_EXTRANEOUS_DEPENDENCY'), + (e[(e.CONSTRAINTS_INVALID_DEPENDENCY = 26)] = + 'CONSTRAINTS_INVALID_DEPENDENCY'), + (e[(e.CANT_SUGGEST_RESOLUTIONS = 27)] = + 'CANT_SUGGEST_RESOLUTIONS'), + (e[(e.FROZEN_LOCKFILE_EXCEPTION = 28)] = + 'FROZEN_LOCKFILE_EXCEPTION'), + (e[(e.CROSS_DRIVE_VIRTUAL_LOCAL = 29)] = + 'CROSS_DRIVE_VIRTUAL_LOCAL'), + (e[(e.FETCH_FAILED = 30)] = 'FETCH_FAILED'), + (e[(e.DANGEROUS_NODE_MODULES = 31)] = 'DANGEROUS_NODE_MODULES'), + (e[(e.NODE_GYP_INJECTED = 32)] = 'NODE_GYP_INJECTED'), + (e[(e.AUTHENTICATION_NOT_FOUND = 33)] = + 'AUTHENTICATION_NOT_FOUND'), + (e[(e.INVALID_CONFIGURATION_KEY = 34)] = + 'INVALID_CONFIGURATION_KEY'), + (e[(e.NETWORK_ERROR = 35)] = 'NETWORK_ERROR'), + (e[(e.LIFECYCLE_SCRIPT = 36)] = 'LIFECYCLE_SCRIPT'), + (e[(e.CONSTRAINTS_MISSING_FIELD = 37)] = + 'CONSTRAINTS_MISSING_FIELD'), + (e[(e.CONSTRAINTS_INCOMPATIBLE_FIELD = 38)] = + 'CONSTRAINTS_INCOMPATIBLE_FIELD'), + (e[(e.CONSTRAINTS_EXTRANEOUS_FIELD = 39)] = + 'CONSTRAINTS_EXTRANEOUS_FIELD'), + (e[(e.CONSTRAINTS_INVALID_FIELD = 40)] = + 'CONSTRAINTS_INVALID_FIELD'), + (e[(e.AUTHENTICATION_INVALID = 41)] = 'AUTHENTICATION_INVALID'), + (e[(e.PROLOG_UNKNOWN_ERROR = 42)] = 'PROLOG_UNKNOWN_ERROR'), + (e[(e.PROLOG_SYNTAX_ERROR = 43)] = 'PROLOG_SYNTAX_ERROR'), + (e[(e.PROLOG_EXISTENCE_ERROR = 44)] = 'PROLOG_EXISTENCE_ERROR'), + (e[(e.STACK_OVERFLOW_RESOLUTION = 45)] = + 'STACK_OVERFLOW_RESOLUTION'), + (e[(e.AUTOMERGE_FAILED_TO_PARSE = 46)] = + 'AUTOMERGE_FAILED_TO_PARSE'), + (e[(e.AUTOMERGE_IMMUTABLE = 47)] = 'AUTOMERGE_IMMUTABLE'), + (e[(e.AUTOMERGE_SUCCESS = 48)] = 'AUTOMERGE_SUCCESS'), + (e[(e.AUTOMERGE_REQUIRED = 49)] = 'AUTOMERGE_REQUIRED'), + (e[(e.DEPRECATED_CLI_SETTINGS = 50)] = 'DEPRECATED_CLI_SETTINGS'), + (e[(e.PLUGIN_NAME_NOT_FOUND = 51)] = 'PLUGIN_NAME_NOT_FOUND'), + (e[(e.INVALID_PLUGIN_REFERENCE = 52)] = + 'INVALID_PLUGIN_REFERENCE'), + (e[(e.CONSTRAINTS_AMBIGUITY = 53)] = 'CONSTRAINTS_AMBIGUITY'), + (e[(e.CACHE_OUTSIDE_PROJECT = 54)] = 'CACHE_OUTSIDE_PROJECT'), + (e[(e.IMMUTABLE_INSTALL = 55)] = 'IMMUTABLE_INSTALL'), + (e[(e.IMMUTABLE_CACHE = 56)] = 'IMMUTABLE_CACHE'), + (e[(e.INVALID_MANIFEST = 57)] = 'INVALID_MANIFEST'), + (e[(e.PACKAGE_PREPARATION_FAILED = 58)] = + 'PACKAGE_PREPARATION_FAILED'), + (e[(e.INVALID_RANGE_PEER_DEPENDENCY = 59)] = + 'INVALID_RANGE_PEER_DEPENDENCY'), + (e[(e.INCOMPATIBLE_PEER_DEPENDENCY = 60)] = + 'INCOMPATIBLE_PEER_DEPENDENCY'), + (e[(e.DEPRECATED_PACKAGE = 61)] = 'DEPRECATED_PACKAGE'), + (e[(e.INCOMPATIBLE_OS = 62)] = 'INCOMPATIBLE_OS'), + (e[(e.INCOMPATIBLE_CPU = 63)] = 'INCOMPATIBLE_CPU'), + (e[(e.FROZEN_ARTIFACT_EXCEPTION = 64)] = + 'FROZEN_ARTIFACT_EXCEPTION'), + (e[(e.TELEMETRY_NOTICE = 65)] = 'TELEMETRY_NOTICE'), + (e[(e.PATCH_HUNK_FAILED = 66)] = 'PATCH_HUNK_FAILED'), + (e[(e.INVALID_CONFIGURATION_VALUE = 67)] = + 'INVALID_CONFIGURATION_VALUE'), + (e[(e.UNUSED_PACKAGE_EXTENSION = 68)] = + 'UNUSED_PACKAGE_EXTENSION'), + (e[(e.REDUNDANT_PACKAGE_EXTENSION = 69)] = + 'REDUNDANT_PACKAGE_EXTENSION'); + })(A || (A = {})); + }, + 27092: (e, t, r) => { + 'use strict'; + r.d(t, { B: () => n }); + var A = r(54143); + class n { + constructor(e) { + this.resolvers = e.filter((e) => e); + } + supportsDescriptor(e, t) { + return !!this.tryResolverByDescriptor(e, t); + } + supportsLocator(e, t) { + return !!this.tryResolverByLocator(e, t); + } + shouldPersistResolution(e, t) { + return this.getResolverByLocator(e, t).shouldPersistResolution( + e, + t + ); + } + bindDescriptor(e, t, r) { + return this.getResolverByDescriptor(e, r).bindDescriptor(e, t, r); + } + getResolutionDependencies(e, t) { + return this.getResolverByDescriptor(e, t).getResolutionDependencies( + e, + t + ); + } + async getCandidates(e, t, r) { + const A = this.getResolverByDescriptor(e, r); + return await A.getCandidates(e, t, r); + } + async getSatisfying(e, t, r) { + return this.getResolverByDescriptor(e, r).getSatisfying(e, t, r); + } + async resolve(e, t) { + const r = this.getResolverByLocator(e, t); + return await r.resolve(e, t); + } + tryResolverByDescriptor(e, t) { + const r = this.resolvers.find((r) => r.supportsDescriptor(e, t)); + return r || null; + } + getResolverByDescriptor(e, t) { + const r = this.resolvers.find((r) => r.supportsDescriptor(e, t)); + if (!r) + throw new Error( + A.prettyDescriptor(t.project.configuration, e) + + " isn't supported by any available resolver" + ); + return r; + } + tryResolverByLocator(e, t) { + const r = this.resolvers.find((r) => r.supportsLocator(e, t)); + return r || null; + } + getResolverByLocator(e, t) { + const r = this.resolvers.find((r) => r.supportsLocator(e, t)); + if (!r) + throw new Error( + A.prettyLocator(t.project.configuration, e) + + " isn't supported by any available resolver" + ); + return r; + } + } + }, + 85824: (e, t, r) => { + 'use strict'; + r.d(t, { I: () => ie }); + var A = r(43896), + n = r(46009), + o = r(5944), + i = r(11640), + s = r(40822), + a = r(76417); + function c() {} + function g(e, t, r, A, n) { + for (var o = 0, i = t.length, s = 0, a = 0; o < i; o++) { + var c = t[o]; + if (c.removed) { + if ( + ((c.value = e.join(A.slice(a, a + c.count))), + (a += c.count), + o && t[o - 1].added) + ) { + var g = t[o - 1]; + (t[o - 1] = t[o]), (t[o] = g); + } + } else { + if (!c.added && n) { + var l = r.slice(s, s + c.count); + (l = l.map(function (e, t) { + var r = A[a + t]; + return r.length > e.length ? r : e; + })), + (c.value = e.join(l)); + } else c.value = e.join(r.slice(s, s + c.count)); + (s += c.count), c.added || (a += c.count); + } + } + var u = t[i - 1]; + return ( + i > 1 && + 'string' == typeof u.value && + (u.added || u.removed) && + e.equals('', u.value) && + ((t[i - 2].value += u.value), t.pop()), + t + ); + } + function l(e) { + return { newPos: e.newPos, components: e.components.slice(0) }; + } + c.prototype = { + diff: function (e, t) { + var r = + arguments.length > 2 && void 0 !== arguments[2] + ? arguments[2] + : {}, + A = r.callback; + 'function' == typeof r && ((A = r), (r = {})), (this.options = r); + var n = this; + function o(e) { + return A + ? (setTimeout(function () { + A(void 0, e); + }, 0), + !0) + : e; + } + (e = this.castInput(e)), + (t = this.castInput(t)), + (e = this.removeEmpty(this.tokenize(e))); + var i = (t = this.removeEmpty(this.tokenize(t))).length, + s = e.length, + a = 1, + c = i + s, + u = [{ newPos: -1, components: [] }], + h = this.extractCommon(u[0], t, e, 0); + if (u[0].newPos + 1 >= i && h + 1 >= s) + return o([{ value: this.join(t), count: t.length }]); + function p() { + for (var r = -1 * a; r <= a; r += 2) { + var A = void 0, + c = u[r - 1], + h = u[r + 1], + p = (h ? h.newPos : 0) - r; + c && (u[r - 1] = void 0); + var d = c && c.newPos + 1 < i, + C = h && 0 <= p && p < s; + if (d || C) { + if ( + (!d || (C && c.newPos < h.newPos) + ? ((A = l(h)), n.pushComponent(A.components, void 0, !0)) + : ((A = c).newPos++, + n.pushComponent(A.components, !0, void 0)), + (p = n.extractCommon(A, t, e, r)), + A.newPos + 1 >= i && p + 1 >= s) + ) + return o(g(n, A.components, t, e, n.useLongestToken)); + u[r] = A; + } else u[r] = void 0; + } + a++; + } + if (A) + !(function e() { + setTimeout(function () { + if (a > c) return A(); + p() || e(); + }, 0); + })(); + else + for (; a <= c; ) { + var d = p(); + if (d) return d; + } + }, + pushComponent: function (e, t, r) { + var A = e[e.length - 1]; + A && A.added === t && A.removed === r + ? (e[e.length - 1] = { count: A.count + 1, added: t, removed: r }) + : e.push({ count: 1, added: t, removed: r }); + }, + extractCommon: function (e, t, r, A) { + for ( + var n = t.length, o = r.length, i = e.newPos, s = i - A, a = 0; + i + 1 < n && s + 1 < o && this.equals(t[i + 1], r[s + 1]); + + ) + i++, s++, a++; + return a && e.components.push({ count: a }), (e.newPos = i), s; + }, + equals: function (e, t) { + return this.options.comparator + ? this.options.comparator(e, t) + : e === t || + (this.options.ignoreCase && + e.toLowerCase() === t.toLowerCase()); + }, + removeEmpty: function (e) { + for (var t = [], r = 0; r < e.length; r++) e[r] && t.push(e[r]); + return t; + }, + castInput: function (e) { + return e; + }, + tokenize: function (e) { + return e.split(''); + }, + join: function (e) { + return e.join(''); + }, + }; + new c(); + var u = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/, + h = /\S/, + p = new c(); + (p.equals = function (e, t) { + return ( + this.options.ignoreCase && + ((e = e.toLowerCase()), (t = t.toLowerCase())), + e === t || + (this.options.ignoreWhitespace && !h.test(e) && !h.test(t)) + ); + }), + (p.tokenize = function (e) { + for ( + var t = e.split(/(\s+|[()[\]{}'"]|\b)/), r = 0; + r < t.length - 1; + r++ + ) + !t[r + 1] && + t[r + 2] && + u.test(t[r]) && + u.test(t[r + 2]) && + ((t[r] += t[r + 2]), t.splice(r + 1, 2), r--); + return t; + }); + var d = new c(); + d.tokenize = function (e) { + var t = [], + r = e.split(/(\n|\r\n)/); + r[r.length - 1] || r.pop(); + for (var A = 0; A < r.length; A++) { + var n = r[A]; + A % 2 && !this.options.newlineIsToken + ? (t[t.length - 1] += n) + : (this.options.ignoreWhitespace && (n = n.trim()), t.push(n)); + } + return t; + }; + var C = new c(); + C.tokenize = function (e) { + return e.split(/(\S.+?[.!?])(?=\s+|$)/); + }; + var f = new c(); + function I(e) { + return (I = + 'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator + ? function (e) { + return typeof e; + } + : function (e) { + return e && + 'function' == typeof Symbol && + e.constructor === Symbol && + e !== Symbol.prototype + ? 'symbol' + : typeof e; + })(e); + } + function E(e) { + return ( + (function (e) { + if (Array.isArray(e)) { + for (var t = 0, r = new Array(e.length); t < e.length; t++) + r[t] = e[t]; + return r; + } + })(e) || + (function (e) { + if ( + Symbol.iterator in Object(e) || + '[object Arguments]' === Object.prototype.toString.call(e) + ) + return Array.from(e); + })(e) || + (function () { + throw new TypeError( + 'Invalid attempt to spread non-iterable instance' + ); + })() + ); + } + f.tokenize = function (e) { + return e.split(/([{}:;,]|\s+)/); + }; + var B = Object.prototype.toString, + y = new c(); + (y.useLongestToken = !0), + (y.tokenize = d.tokenize), + (y.castInput = function (e) { + var t = this.options, + r = t.undefinedReplacement, + A = t.stringifyReplacer, + n = + void 0 === A + ? function (e, t) { + return void 0 === t ? r : t; + } + : A; + return 'string' == typeof e + ? e + : JSON.stringify( + (function e(t, r, A, n, o) { + (r = r || []), (A = A || []), n && (t = n(o, t)); + var i, s; + for (i = 0; i < r.length; i += 1) + if (r[i] === t) return A[i]; + if ('[object Array]' === B.call(t)) { + for ( + r.push(t), s = new Array(t.length), A.push(s), i = 0; + i < t.length; + i += 1 + ) + s[i] = e(t[i], r, A, n, o); + return r.pop(), A.pop(), s; + } + t && t.toJSON && (t = t.toJSON()); + if ('object' === I(t) && null !== t) { + r.push(t), (s = {}), A.push(s); + var a, + c = []; + for (a in t) t.hasOwnProperty(a) && c.push(a); + for (c.sort(), i = 0; i < c.length; i += 1) + (a = c[i]), (s[a] = e(t[a], r, A, n, a)); + r.pop(), A.pop(); + } else s = t; + return s; + })(e, null, null, n), + n, + ' ' + ); + }), + (y.equals = function (e, t) { + return c.prototype.equals.call( + y, + e.replace(/,([\r\n])/g, '$1'), + t.replace(/,([\r\n])/g, '$1') + ); + }); + var m = new c(); + function w(e, t, r, A, n, o, i) { + i || (i = {}), void 0 === i.context && (i.context = 4); + var s = (function (e, t, r) { + return d.diff(e, t, r); + })(r, A, i); + function a(e) { + return e.map(function (e) { + return ' ' + e; + }); + } + s.push({ value: '', lines: [] }); + for ( + var c = [], + g = 0, + l = 0, + u = [], + h = 1, + p = 1, + C = function (e) { + var t = s[e], + n = t.lines || t.value.replace(/\n$/, '').split('\n'); + if (((t.lines = n), t.added || t.removed)) { + var o; + if (!g) { + var d = s[e - 1]; + (g = h), + (l = p), + d && + ((u = + i.context > 0 ? a(d.lines.slice(-i.context)) : []), + (g -= u.length), + (l -= u.length)); + } + (o = u).push.apply( + o, + E( + n.map(function (e) { + return (t.added ? '+' : '-') + e; + }) + ) + ), + t.added ? (p += n.length) : (h += n.length); + } else { + if (g) + if (n.length <= 2 * i.context && e < s.length - 2) { + var C; + (C = u).push.apply(C, E(a(n))); + } else { + var f, + I = Math.min(n.length, i.context); + (f = u).push.apply(f, E(a(n.slice(0, I)))); + var B = { + oldStart: g, + oldLines: h - g + I, + newStart: l, + newLines: p - l + I, + lines: u, + }; + if (e >= s.length - 2 && n.length <= i.context) { + var y = /\n$/.test(r), + m = /\n$/.test(A), + w = 0 == n.length && u.length > B.oldLines; + !y && + w && + u.splice( + B.oldLines, + 0, + '\\ No newline at end of file' + ), + ((y || w) && m) || + u.push('\\ No newline at end of file'); + } + c.push(B), (g = 0), (l = 0), (u = []); + } + (h += n.length), (p += n.length); + } + }, + f = 0; + f < s.length; + f++ + ) + C(f); + return { + oldFileName: e, + newFileName: t, + oldHeader: n, + newHeader: o, + hunks: c, + }; + } + (m.tokenize = function (e) { + return e.slice(); + }), + (m.join = m.removeEmpty = function (e) { + return e; + }); + var Q = r(75130), + D = r.n(Q), + b = r(61578), + v = r.n(b), + S = r(53887), + k = r.n(S), + N = r(31669); + const F = require('v8'); + var K = r.n(F), + M = r(78761), + R = r.n(M), + x = r(39922), + L = r(92409), + P = r(92659), + O = r(54143); + const U = [ + [ + /^(git(?:\+(?:https|ssh))?:\/\/.*(?:\.git)?)#(.*)$/, + (e, t, r, A) => `${r}#commit=${A}`, + ], + [ + /^https:\/\/((?:[^/]+?)@)?codeload\.github\.com\/([^/]+\/[^/]+)\/tar\.gz\/([0-9a-f]+)$/, + (e, t, r = '', A, n) => + `https://${r}github.com/${A}.git#commit=${n}`, + ], + [ + /^https:\/\/((?:[^/]+?)@)?github\.com\/([^/]+\/[^/]+?)(?:\.git)?#([0-9a-f]+)$/, + (e, t, r = '', A, n) => + `https://${r}github.com/${A}.git#commit=${n}`, + ], + [ + /^https?:\/\/[^/]+\/(?:[^/]+\/)*(?:@[^/]+\/)?([^/]+)\/(?:-|download)\/\1-[^/]+\.tgz(?:#|$)/, + (e) => 'npm:' + e, + ], + [ + /^https:\/\/npm\.pkg\.github\.com\/download\/(?:@[^/]+)\/(?:[^/]+)\/(?:[^/]+)\/(?:[0-9a-f]+)$/, + (e) => 'npm:' + e, + ], + [ + /^https:\/\/npm\.fontawesome\.com\/(?:@[^/]+)\/([^/]+)\/-\/([^/]+)\/\1-\2.tgz(?:#|$)/, + (e) => 'npm:' + e, + ], + [/^[^/]+\.tgz#[0-9a-f]+$/, (e) => 'npm:' + e], + ]; + class T { + constructor() { + this.resolutions = null; + } + async setup(e, { report: t }) { + const r = n.y1.join(e.cwd, e.configuration.get('lockfileFilename')); + if (!A.xfs.existsSync(r)) return; + const o = await A.xfs.readFilePromise(r, 'utf8'), + s = (0, i.parseSyml)(o); + if (Object.prototype.hasOwnProperty.call(s, '__metadata')) return; + const a = (this.resolutions = new Map()); + for (const r of Object.keys(s)) { + let A = O.tryParseDescriptor(r); + if (!A) { + t.reportWarning( + P.b.YARN_IMPORT_FAILED, + `Failed to parse the string "${r}" into a proper descriptor` + ); + continue; + } + k().validRange(A.range) && + (A = O.makeDescriptor(A, 'npm:' + A.range)); + const { version: n, resolved: o } = s[r]; + if (!o) continue; + let i; + for (const [e, t] of U) { + const r = o.match(e); + if (r) { + i = t(n, ...r); + break; + } + } + if (!i) { + t.reportWarning( + P.b.YARN_IMPORT_FAILED, + `${O.prettyDescriptor( + e.configuration, + A + )}: Only some patterns can be imported from legacy lockfiles (not "${o}")` + ); + continue; + } + const c = O.makeLocator(A, i); + a.set(A.descriptorHash, c); + } + } + supportsDescriptor(e, t) { + return !!this.resolutions && this.resolutions.has(e.descriptorHash); + } + supportsLocator(e, t) { + return !1; + } + shouldPersistResolution(e, t) { + throw new Error( + "Assertion failed: This resolver doesn't support resolving locators to packages" + ); + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + if (!this.resolutions) + throw new Error( + 'Assertion failed: The resolution store should have been setup' + ); + const A = this.resolutions.get(e.descriptorHash); + if (!A) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + return [A]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + throw new Error( + "Assertion failed: This resolver doesn't support resolving locators to packages" + ); + } + } + class j { + supportsDescriptor(e, t) { + return ( + !!t.project.storedResolutions.get(e.descriptorHash) || + !!t.project.originalPackages.has( + O.convertDescriptorToLocator(e).locatorHash + ) + ); + } + supportsLocator(e, t) { + return !!t.project.originalPackages.has(e.locatorHash); + } + shouldPersistResolution(e, t) { + throw new Error( + "The shouldPersistResolution method shouldn't be called on the lockfile resolver, which would always answer yes" + ); + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + let A = r.project.originalPackages.get( + O.convertDescriptorToLocator(e).locatorHash + ); + if (A) return [A]; + const n = r.project.storedResolutions.get(e.descriptorHash); + if (!n) + throw new Error( + 'Expected the resolution to have been successful - resolution not found' + ); + if (((A = r.project.originalPackages.get(n)), !A)) + throw new Error( + 'Expected the resolution to have been successful - package not found' + ); + return [A]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + const r = t.project.originalPackages.get(e.locatorHash); + if (!r) + throw new Error( + "The lockfile resolver isn't meant to resolve packages - they should already have been stored into a cache" + ); + return r; + } + } + var Y = r(46611), + G = r(27092), + H = r(35691); + class J { + constructor(e) { + this.resolver = e; + } + supportsDescriptor(e, t) { + return this.resolver.supportsDescriptor(e, t); + } + supportsLocator(e, t) { + return this.resolver.supportsLocator(e, t); + } + shouldPersistResolution(e, t) { + return this.resolver.shouldPersistResolution(e, t); + } + bindDescriptor(e, t, r) { + return this.resolver.bindDescriptor(e, t, r); + } + getResolutionDependencies(e, t) { + return this.resolver.getResolutionDependencies(e, t); + } + async getCandidates(e, t, r) { + throw new H.lk( + P.b.MISSING_LOCKFILE_ENTRY, + "This package doesn't seem to be present in your lockfile; try to make an install to update your resolutions" + ); + } + async getSatisfying(e, t, r) { + throw new H.lk( + P.b.MISSING_LOCKFILE_ENTRY, + "This package doesn't seem to be present in your lockfile; try to make an install to update your resolutions" + ); + } + async resolve(e, t) { + throw new H.lk( + P.b.MISSING_LOCKFILE_ENTRY, + "This package doesn't seem to be present in your lockfile; try to make an install to update your resolutions" + ); + } + } + var q = r(33720), + z = r(17722), + W = r(81111), + V = r(71643), + X = r(20624), + _ = r(73632), + Z = r(63088), + $ = r(36545), + ee = r(32485); + const te = / *, */g, + re = /\/$/, + Ae = (0, N.promisify)(R().gzip), + ne = (0, N.promisify)(R().gunzip), + oe = { + restoreInstallersCustomData: ['installersCustomData'], + restoreResolutions: [ + 'accessibleLocators', + 'optionalBuilds', + 'storedDescriptors', + 'storedResolutions', + 'storedPackages', + 'lockFileChecksum', + ], + }; + class ie { + constructor(e, { configuration: t }) { + (this.resolutionAliases = new Map()), + (this.workspaces = []), + (this.workspacesByCwd = new Map()), + (this.workspacesByIdent = new Map()), + (this.storedResolutions = new Map()), + (this.storedDescriptors = new Map()), + (this.storedPackages = new Map()), + (this.storedChecksums = new Map()), + (this.accessibleLocators = new Set()), + (this.originalPackages = new Map()), + (this.optionalBuilds = new Set()), + (this.peerRequirements = new Map()), + (this.installersCustomData = new Map()), + (this.lockFileChecksum = null), + (this.configuration = t), + (this.cwd = e); + } + static async find(e, t) { + var r, o, i; + if (!e.projectCwd) + throw new s.UsageError('No project found in ' + t); + let a = e.projectCwd, + c = t, + g = null; + for (; g !== e.projectCwd; ) { + if (((g = c), A.xfs.existsSync(n.y1.join(g, n.QS.manifest)))) { + a = g; + break; + } + c = n.y1.dirname(g); + } + const l = new ie(e.projectCwd, { configuration: e }); + null === (r = x.VK.telemetry) || + void 0 === r || + r.reportProject(l.cwd), + await l.setupResolutions(), + await l.setupWorkspaces(), + null === (o = x.VK.telemetry) || + void 0 === o || + o.reportWorkspaceCount(l.workspaces.length), + null === (i = x.VK.telemetry) || + void 0 === i || + i.reportDependencyCount( + l.workspaces.reduce( + (e, t) => + e + + t.manifest.dependencies.size + + t.manifest.devDependencies.size, + 0 + ) + ); + const u = l.tryWorkspaceByCwd(a); + if (u) + return { project: l, workspace: u, locator: u.anchoredLocator }; + const h = await l.findLocatorForLocation(a + '/', { strict: !0 }); + if (h) return { project: l, locator: h, workspace: null }; + throw new s.UsageError( + `The nearest package directory (${V.pretty( + e, + a, + V.Type.PATH + )}) doesn't seem to be part of the project declared in ${V.pretty( + e, + l.cwd, + V.Type.PATH + )}.\n\n- If the project directory is right, it might be that you forgot to list ${V.pretty( + e, + n.y1.relative(l.cwd, a), + V.Type.PATH + )} as a workspace.\n- If it isn't, it's likely because you have a yarn.lock or package.json file there, confusing the project root detection.` + ); + } + static generateBuildStateFile(e, t) { + let r = + '# Warning: This file is automatically generated. Removing it is fine, but will\n# cause all your builds to become invalidated.\n'; + const A = [...e].map(([e, r]) => { + const A = t.get(e); + if (void 0 === A) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + return [O.stringifyLocator(A), A.locatorHash, r]; + }); + for (const [e, t, n] of _.sortMap(A, [(e) => e[0], (e) => e[1]])) + (r += '\n'), + (r += `# ${e}\n`), + (r += JSON.stringify(t) + ':\n'), + (r += ` ${n}\n`); + return r; + } + async setupResolutions() { + (this.storedResolutions = new Map()), + (this.storedDescriptors = new Map()), + (this.storedPackages = new Map()), + (this.lockFileChecksum = null); + const e = n.y1.join( + this.cwd, + this.configuration.get('lockfileFilename') + ), + t = this.configuration.get('defaultLanguageName'); + if (A.xfs.existsSync(e)) { + const r = await A.xfs.readFilePromise(e, 'utf8'); + this.lockFileChecksum = X.makeHash('1', r); + const n = (0, i.parseSyml)(r); + if (n.__metadata) { + const e = n.__metadata.version, + r = n.__metadata.cacheKey; + for (const A of Object.keys(n)) { + if ('__metadata' === A) continue; + const o = n[A]; + if (void 0 === o.resolution) + throw new Error( + `Assertion failed: Expected the lockfile entry to have a resolution field (${A})` + ); + const i = O.parseLocator(o.resolution, !0), + s = new Y.G(); + s.load(o, { yamlCompatibilityMode: !0 }); + const a = s.version, + c = s.languageName || t, + g = o.linkType.toUpperCase(), + l = s.dependencies, + u = s.peerDependencies, + h = s.dependenciesMeta, + p = s.peerDependenciesMeta, + d = s.bin; + if (null != o.checksum) { + const e = + void 0 === r || o.checksum.includes('/') + ? o.checksum + : `${r}/${o.checksum}`; + this.storedChecksums.set(i.locatorHash, e); + } + if (e >= 4) { + const e = { + ...i, + version: a, + languageName: c, + linkType: g, + dependencies: l, + peerDependencies: u, + dependenciesMeta: h, + peerDependenciesMeta: p, + bin: d, + }; + this.originalPackages.set(e.locatorHash, e); + } + for (const t of A.split(te)) { + const r = O.parseDescriptor(t); + if ( + (this.storedDescriptors.set(r.descriptorHash, r), e >= 4) + ) + this.storedResolutions.set( + r.descriptorHash, + i.locatorHash + ); + else { + const e = O.convertLocatorToDescriptor(i); + e.descriptorHash !== r.descriptorHash && + (this.storedDescriptors.set(e.descriptorHash, e), + this.resolutionAliases.set( + r.descriptorHash, + e.descriptorHash + )); + } + } + } + } + } + } + async setupWorkspaces() { + (this.workspaces = []), + (this.workspacesByCwd = new Map()), + (this.workspacesByIdent = new Map()); + let e = [this.cwd]; + for (; e.length > 0; ) { + const t = e; + e = []; + for (const r of t) { + if (this.workspacesByCwd.has(r)) continue; + const t = await this.addWorkspace(r), + A = this.storedPackages.get(t.anchoredLocator.locatorHash); + A && (t.dependencies = A.dependencies); + for (const r of t.workspacesCwds) e.push(r); + } + } + } + async addWorkspace(e) { + const t = new z.j(e, { project: this }); + await t.setup(); + const r = this.workspacesByIdent.get(t.locator.identHash); + if (void 0 !== r) + throw new Error( + `Duplicate workspace name ${O.prettyIdent( + this.configuration, + t.locator + )}: ${e} conflicts with ${r.cwd}` + ); + return ( + this.workspaces.push(t), + this.workspacesByCwd.set(e, t), + this.workspacesByIdent.set(t.locator.identHash, t), + t + ); + } + get topLevelWorkspace() { + return this.getWorkspaceByCwd(this.cwd); + } + tryWorkspaceByCwd(e) { + n.y1.isAbsolute(e) || (e = n.y1.resolve(this.cwd, e)), + (e = n.y1.normalize(e).replace(/\/+$/, '')); + const t = this.workspacesByCwd.get(e); + return t || null; + } + getWorkspaceByCwd(e) { + const t = this.tryWorkspaceByCwd(e); + if (!t) throw new Error(`Workspace not found (${e})`); + return t; + } + tryWorkspaceByFilePath(e) { + let t = null; + for (const r of this.workspaces) { + n.y1.relative(r.cwd, e).startsWith('../') || + (t && t.cwd.length >= r.cwd.length) || + (t = r); + } + return t || null; + } + getWorkspaceByFilePath(e) { + const t = this.tryWorkspaceByFilePath(e); + if (!t) throw new Error(`Workspace not found (${e})`); + return t; + } + tryWorkspaceByIdent(e) { + const t = this.workspacesByIdent.get(e.identHash); + return void 0 === t ? null : t; + } + getWorkspaceByIdent(e) { + const t = this.tryWorkspaceByIdent(e); + if (!t) + throw new Error( + `Workspace not found (${O.prettyIdent(this.configuration, e)})` + ); + return t; + } + tryWorkspaceByDescriptor(e) { + const t = this.tryWorkspaceByIdent(e); + return null !== t && t.accepts(e.range) ? t : null; + } + getWorkspaceByDescriptor(e) { + const t = this.tryWorkspaceByDescriptor(e); + if (null === t) + throw new Error( + `Workspace not found (${O.prettyDescriptor( + this.configuration, + e + )})` + ); + return t; + } + tryWorkspaceByLocator(e) { + O.isVirtualLocator(e) && (e = O.devirtualizeLocator(e)); + const t = this.tryWorkspaceByIdent(e); + return null === t || + (t.locator.locatorHash !== e.locatorHash && + t.anchoredLocator.locatorHash !== e.locatorHash) + ? null + : t; + } + getWorkspaceByLocator(e) { + const t = this.tryWorkspaceByLocator(e); + if (!t) + throw new Error( + `Workspace not found (${O.prettyLocator( + this.configuration, + e + )})` + ); + return t; + } + refreshWorkspaceDependencies() { + for (const e of this.workspaces) { + const t = this.storedPackages.get(e.anchoredLocator.locatorHash); + if (!t) + throw new Error( + 'Assertion failed: Expected workspace to have been resolved' + ); + e.dependencies = new Map(t.dependencies); + } + } + forgetResolution(e) { + const t = (e) => { + this.storedResolutions.delete(e), + this.storedDescriptors.delete(e); + }, + r = (e) => { + this.originalPackages.delete(e), + this.storedPackages.delete(e), + this.accessibleLocators.delete(e); + }; + if ('descriptorHash' in e) { + const A = this.storedResolutions.get(e.descriptorHash); + t(e.descriptorHash); + const n = new Set(this.storedResolutions.values()); + void 0 === A || n.has(A) || r(A); + } + if ('locatorHash' in e) { + r(e.locatorHash); + for (const [r, A] of this.storedResolutions) + A === e.locatorHash && t(r); + } + } + forgetTransientResolutions() { + const e = this.configuration.makeResolver(); + for (const t of this.originalPackages.values()) { + let r; + try { + r = e.shouldPersistResolution(t, { + project: this, + resolver: e, + }); + } catch (e) { + r = !1; + } + r || this.forgetResolution(t); + } + } + forgetVirtualResolutions() { + for (const e of this.storedPackages.values()) + for (const [t, r] of e.dependencies) + O.isVirtualDescriptor(r) && + e.dependencies.set(t, O.devirtualizeDescriptor(r)); + } + getDependencyMeta(e, t) { + const r = {}, + A = this.topLevelWorkspace.manifest.dependenciesMeta.get( + O.stringifyIdent(e) + ); + if (!A) return r; + const n = A.get(null); + if ((n && Object.assign(r, n), null === t || !k().valid(t))) + return r; + for (const [e, n] of A) + null !== e && e === t && Object.assign(r, n); + return r; + } + async findLocatorForLocation(e, { strict: t = !1 } = {}) { + const r = new q.$(), + A = this.configuration.getLinkers(), + n = { project: this, report: r }; + for (const r of A) { + const A = await r.findPackageLocator(e, n); + if (A) { + if (t) { + if ( + (await r.findPackageLocation(A, n)).replace(re, '') !== + e.replace(re, '') + ) + continue; + } + return A; + } + } + return null; + } + async resolveEverything(e) { + if (!this.workspacesByCwd || !this.workspacesByIdent) + throw new Error( + 'Workspaces must have been setup before calling this function' + ); + this.forgetVirtualResolutions(), + e.lockfileOnly || this.forgetTransientResolutions(); + const t = e.resolver || this.configuration.makeResolver(), + r = new T(); + await r.setup(this, { report: e.report }); + const o = e.lockfileOnly + ? new G.B([new j(), new J(t)]) + : new G.B([new j(), r, t]), + i = this.configuration.makeFetcher(), + s = e.lockfileOnly + ? { project: this, report: e.report, resolver: o } + : { + project: this, + report: e.report, + resolver: o, + fetchOptions: { + project: this, + cache: e.cache, + checksums: this.storedChecksums, + report: e.report, + fetcher: i, + }, + }, + a = new Map(), + c = new Map(), + g = new Map(), + l = new Map(), + u = new Map(), + h = new Map(), + p = [], + d = async (e) => { + const t = await _.prettifyAsyncErrors( + async () => await o.resolve(e, s), + (t) => `${O.prettyLocator(this.configuration, e)}: ${t}` + ); + if (!O.areLocatorsEqual(e, t)) + throw new Error( + `Assertion failed: The locator cannot be changed by the resolver (went from ${O.prettyLocator( + this.configuration, + e + )} to ${O.prettyLocator(this.configuration, t)})` + ); + l.set(t.locatorHash, t); + const r = this.configuration.normalizePackage(t); + for (const [t, A] of r.dependencies) { + const n = await this.configuration.reduceHook( + (e) => e.reduceDependency, + A, + this, + r, + A, + { resolver: o, resolveOptions: s } + ); + if (!O.areIdentsEqual(A, n)) + throw new Error( + 'Assertion failed: The descriptor ident cannot be changed through aliases' + ); + const i = o.bindDescriptor(n, e, s); + r.dependencies.set(t, i); + } + return ( + p.push( + Promise.all([...r.dependencies.values()].map((e) => f(e))) + ), + c.set(r.locatorHash, r), + r + ); + }, + C = async (e) => { + const t = this.resolutionAliases.get(e.descriptorHash); + if (void 0 !== t) + return (async (e, t) => { + const r = await f(t); + return ( + a.set(e.descriptorHash, e), + g.set(e.descriptorHash, r.locatorHash), + r + ); + })(e, this.storedDescriptors.get(t)); + const r = o.getResolutionDependencies(e, s), + A = new Map( + await Promise.all( + r.map(async (e) => [e.descriptorHash, await f(e)]) + ) + ), + n = ( + await _.prettifyAsyncErrors( + async () => await o.getCandidates(e, A, s), + (t) => + `${O.prettyDescriptor(this.configuration, e)}: ${t}` + ) + )[0]; + if (void 0 === n) + throw new Error( + O.prettyDescriptor(this.configuration, e) + + ': No candidates found' + ); + return ( + a.set(e.descriptorHash, e), + g.set(e.descriptorHash, n.locatorHash), + (async (e) => { + const t = u.get(e.locatorHash); + if (void 0 !== t) return t; + const r = Promise.resolve().then(() => d(e)); + return u.set(e.locatorHash, r), r; + })(n) + ); + }, + f = (e) => { + const t = h.get(e.descriptorHash); + if (void 0 !== t) return t; + a.set(e.descriptorHash, e); + const r = Promise.resolve().then(() => C(e)); + return h.set(e.descriptorHash, r), r; + }; + for (const e of this.workspaces) { + const t = e.anchoredDescriptor; + p.push(f(t)); + } + for (; p.length > 0; ) { + const e = [...p]; + (p.length = 0), await Promise.all(e); + } + const I = new Set(this.resolutionAliases.values()), + E = new Set(c.keys()), + B = new Set(), + y = new Map(); + !(function ({ + project: e, + allDescriptors: t, + allResolutions: r, + allPackages: o, + accessibleLocators: i = new Set(), + optionalBuilds: s = new Set(), + volatileDescriptors: a = new Set(), + peerRequirements: c = new Map(), + report: g, + tolerateMissingPackages: l = !1, + }) { + var u; + const h = new Map(), + p = [], + d = new Map(), + C = new Map(), + f = new Map(), + I = new Map(), + E = new Map(), + B = new Map( + e.workspaces.map((e) => { + const t = e.anchoredLocator.locatorHash, + r = o.get(t); + if (void 0 === r) { + if (l) return [t, null]; + throw new Error( + 'Assertion failed: The workspace should have an associated package' + ); + } + return [t, O.copyPackage(r)]; + }) + ), + y = () => { + const e = A.xfs.mktempSync(), + t = n.y1.join(e, 'stacktrace.log'), + r = String(p.length + 1).length, + o = p + .map( + (e, t) => + `${(t + 1 + '.').padStart( + r, + ' ' + )} ${O.stringifyLocator(e)}\n` + ) + .join(''); + throw ( + (A.xfs.writeFileSync(t, o), + new H.lk( + P.b.STACK_OVERFLOW_RESOLUTION, + 'Encountered a stack overflow when resolving peer dependencies; cf ' + + t + )) + ); + }, + m = (e) => { + const t = r.get(e.descriptorHash); + if (void 0 === t) + throw new Error( + 'Assertion failed: The resolution should have been registered' + ); + const A = o.get(t); + if (!A) + throw new Error( + 'Assertion failed: The package could not be found' + ); + return A; + }, + w = (e, t, { first: r, optional: A }) => { + p.length > 1e3 && y(), p.push(e); + const n = Q(e, t, { first: r, optional: A }); + return p.pop(), n; + }, + Q = (A, n, { first: c, optional: g }) => { + if (i.has(A.locatorHash)) return; + i.add(A.locatorHash), g || s.delete(A.locatorHash); + const u = o.get(A.locatorHash); + if (!u) { + if (l) return; + throw new Error( + `Assertion failed: The package (${O.prettyLocator( + e.configuration, + A + )}) should have been registered` + ); + } + const p = [], + m = [], + Q = [], + D = [], + b = []; + for (const i of Array.from(u.dependencies.values())) { + if (u.peerDependencies.has(i.identHash) && !c) continue; + if (O.isVirtualDescriptor(i)) + throw new Error( + "Assertion failed: Virtual packages shouldn't be encountered when virtualizing a branch" + ); + a.delete(i.descriptorHash); + let s = g; + if (!s) { + const e = u.dependenciesMeta.get(O.stringifyIdent(i)); + if (void 0 !== e) { + const t = e.get(null); + void 0 !== t && t.optional && (s = !0); + } + } + const C = r.get(i.descriptorHash); + if (!C) { + if (l) continue; + throw new Error( + `Assertion failed: The resolution (${O.prettyDescriptor( + e.configuration, + i + )}) should have been registered` + ); + } + const v = B.get(C) || o.get(C); + if (!v) + throw new Error( + `Assertion failed: The package (${C}, resolved from ${O.prettyDescriptor( + e.configuration, + i + )}) should have been registered` + ); + if (0 === v.peerDependencies.size) { + w(v, new Map(), { first: !1, optional: s }); + continue; + } + const S = h.get(v.locatorHash); + let k, N; + 'number' == typeof S && S >= 2 && y(); + const F = new Set(); + let K; + m.push(() => { + (k = O.virtualizeDescriptor(i, A.locatorHash)), + (N = O.virtualizePackage(v, A.locatorHash)), + u.dependencies.delete(i.identHash), + u.dependencies.set(k.identHash, k), + r.set(k.descriptorHash, N.locatorHash), + t.set(k.descriptorHash, k), + o.set(N.locatorHash, N), + p.push([v, k, N]); + }), + Q.push(() => { + var e; + K = new Map(); + for (const o of N.peerDependencies.values()) { + let i = u.dependencies.get(o.identHash); + if ( + (!i && + O.areIdentsEqual(A, o) && + ((i = O.convertLocatorToDescriptor(A)), + t.set(i.descriptorHash, i), + r.set(i.descriptorHash, A.locatorHash), + a.delete(i.descriptorHash)), + i || !N.dependencies.has(o.identHash)) + ) { + if ( + (i || (i = O.makeDescriptor(o, 'missing:')), + N.dependencies.set(i.identHash, i), + O.isVirtualDescriptor(i)) + ) { + _.getSetWithDefault(f, i.descriptorHash).add( + N.locatorHash + ); + } + d.set(i.identHash, i), + 'missing:' === i.range && F.add(i.identHash), + K.set( + o.identHash, + null !== (e = n.get(o.identHash)) && + void 0 !== e + ? e + : N.locatorHash + ); + } else N.peerDependencies.delete(o.identHash); + } + N.dependencies = new Map( + _.sortMap(N.dependencies, ([e, t]) => + O.stringifyIdent(t) + ) + ); + }), + D.push(() => { + if (!o.has(N.locatorHash)) return; + const e = h.get(v.locatorHash), + t = void 0 !== e ? e + 1 : 1; + h.set(v.locatorHash, t), + w(N, K, { first: !1, optional: s }), + h.set(v.locatorHash, t - 1); + }), + b.push(() => { + const e = u.dependencies.get(i.identHash); + if (void 0 === e) + throw new Error( + 'Assertion failed: Expected the peer dependency to have been turned into a dependency' + ); + const t = r.get(e.descriptorHash); + if (void 0 === t) + throw new Error( + 'Assertion failed: Expected the descriptor to be registered' + ); + if ( + (_.getSetWithDefault(E, t).add(A.locatorHash), + o.has(N.locatorHash)) + ) { + for (const e of N.peerDependencies.values()) { + const t = K.get(e.identHash); + if (void 0 === t) + throw new Error( + 'Assertion failed: Expected the peer dependency ident to be registered' + ); + _.getArrayWithDefault( + _.getMapWithDefault(I, t), + O.stringifyIdent(e) + ).push(N.locatorHash); + } + for (const e of F) N.dependencies.delete(e); + } + }); + } + for (const e of [...m, ...Q]) e(); + let v; + do { + v = !0; + for (const [A, n, s] of p) { + if (!o.has(s.locatorHash)) continue; + const a = _.getMapWithDefault(C, A.locatorHash), + c = X.makeHash( + ...[...s.dependencies.values()].map((t) => { + const A = + 'missing:' !== t.range + ? r.get(t.descriptorHash) + : 'missing:'; + if (void 0 === A) + throw new Error( + `Assertion failed: Expected the resolution for ${O.prettyDescriptor( + e.configuration, + t + )} to have been registered` + ); + return A; + }), + n.identHash + ), + g = a.get(c); + if (void 0 === g) { + a.set(c, n); + continue; + } + if (g === n) continue; + (v = !1), + o.delete(s.locatorHash), + t.delete(n.descriptorHash), + r.delete(n.descriptorHash), + i.delete(s.locatorHash); + const l = f.get(n.descriptorHash) || [], + h = [u.locatorHash, ...l]; + f.delete(n.descriptorHash); + for (const e of h) { + const t = o.get(e); + void 0 !== t && t.dependencies.set(n.identHash, g); + } + } + } while (!v); + for (const e of [...D, ...b]) e(); + }; + for (const t of e.workspaces) + a.delete(t.anchoredDescriptor.descriptorHash), + w(t.anchoredLocator, new Map(), { first: !0, optional: !1 }); + let D; + !(function (e) { + (e[(e.NotProvided = 0)] = 'NotProvided'), + (e[(e.NotCompatible = 1)] = 'NotCompatible'); + })(D || (D = {})); + const b = []; + for (const [e, t] of E) { + const r = o.get(e); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the root to be registered' + ); + const A = I.get(e); + if (void 0 !== A) + for (const n of t) { + const t = o.get(n); + if (void 0 !== t) + for (const [i, s] of A) { + const A = O.parseIdent(i); + if (t.peerDependencies.has(A.identHash)) continue; + const a = 'p' + X.makeHash(n, i, e).slice(0, 5); + c.set(a, { + subject: n, + requested: A, + rootRequester: e, + allRequesters: s, + }); + const g = r.dependencies.get(A.identHash); + if (void 0 !== g) { + const e = m(g), + n = + null !== (u = e.version) && void 0 !== u + ? u + : '0.0.0', + i = new Set(); + for (const e of s) { + const t = o.get(e); + if (void 0 === t) + throw new Error( + 'Assertion failed: Expected the link to be registered' + ); + const r = t.peerDependencies.get(A.identHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the ident to be registered' + ); + i.add(r.range); + } + [...i].every((e) => + $.satisfiesWithPrereleases(n, e) + ) || + b.push({ + type: D.NotCompatible, + subject: t, + requested: A, + requester: r, + version: n, + hash: a, + requirementCount: s.length, + }); + } else { + const e = r.peerDependenciesMeta.get(i); + (null == e ? void 0 : e.optional) || + b.push({ + type: D.NotProvided, + subject: t, + requested: A, + requester: r, + hash: a, + }); + } + } + } + } + const v = [ + (e) => O.prettyLocatorNoColors(e.subject), + (e) => O.stringifyIdent(e.requested), + (e) => '' + e.type, + ]; + for (const t of _.sortMap(b, v)) + switch (t.type) { + case D.NotProvided: + null == g || + g.reportWarning( + P.b.MISSING_PEER_DEPENDENCY, + `${O.prettyLocator( + e.configuration, + t.subject + )} doesn't provide ${O.prettyIdent( + e.configuration, + t.requested + )} (${V.pretty( + e.configuration, + t.hash, + V.Type.CODE + )}), requested by ${O.prettyIdent( + e.configuration, + t.requester + )}` + ); + break; + case D.NotCompatible: { + const r = + t.requirementCount > 1 + ? 'and some of its descendants request' + : 'requests'; + null == g || + g.reportWarning( + P.b.INCOMPATIBLE_PEER_DEPENDENCY, + `${O.prettyLocator( + e.configuration, + t.subject + )} provides ${O.prettyIdent( + e.configuration, + t.requested + )} (${V.pretty( + e.configuration, + t.hash, + V.Type.CODE + )}) with version ${O.prettyReference( + e.configuration, + t.version + )}, which doesn't satisfy what ${O.prettyIdent( + e.configuration, + t.requester + )} ${r}` + ); + } + } + b.length > 0 && + (null == g || + g.reportWarning( + P.b.UNNAMED, + `Some peer dependencies are incorrectly met; run ${V.pretty( + e.configuration, + 'yarn explain peer-requirements ', + V.Type.CODE + )} for details, where ${V.pretty( + e.configuration, + '', + V.Type.CODE + )} is the six-letter p-prefixed code` + )); + })({ + project: this, + report: e.report, + accessibleLocators: B, + volatileDescriptors: I, + optionalBuilds: E, + peerRequirements: y, + allDescriptors: a, + allResolutions: g, + allPackages: c, + }); + for (const e of I) a.delete(e), g.delete(e); + (this.storedResolutions = g), + (this.storedDescriptors = a), + (this.storedPackages = c), + (this.accessibleLocators = B), + (this.originalPackages = l), + (this.optionalBuilds = E), + (this.peerRequirements = y), + this.refreshWorkspaceDependencies(); + } + async fetchEverything({ cache: e, report: t, fetcher: r }) { + const A = r || this.configuration.makeFetcher(), + n = { + checksums: this.storedChecksums, + project: this, + cache: e, + fetcher: A, + report: t, + }, + o = Array.from( + new Set( + _.sortMap(this.storedResolutions.values(), [ + (e) => { + const t = this.storedPackages.get(e); + if (!t) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + return O.stringifyLocator(t); + }, + ]) + ) + ); + let i = !1; + const s = H.yG.progressViaCounter(o.length); + t.reportProgress(s); + const a = v()(32); + if ( + (await t.startCacheReport(async () => { + await Promise.all( + o.map((e) => + a(async () => { + const r = this.storedPackages.get(e); + if (!r) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + if (O.isVirtualLocator(r)) return; + let o; + try { + o = await A.fetch(r, n); + } catch (e) { + return ( + (e.message = `${O.prettyLocator( + this.configuration, + r + )}: ${e.message}`), + t.reportExceptionOnce(e), + void (i = e) + ); + } + o.checksum + ? this.storedChecksums.set(r.locatorHash, o.checksum) + : this.storedChecksums.delete(r.locatorHash), + o.releaseFs && o.releaseFs(); + }).finally(() => { + s.tick(); + }) + ) + ); + }), + i) + ) + throw i; + } + async linkEverything({ + cache: e, + report: t, + fetcher: r, + skipBuild: o, + }) { + var s; + const c = r || this.configuration.makeFetcher(), + g = { + checksums: this.storedChecksums, + project: this, + cache: e, + fetcher: c, + report: t, + skipIntegrityCheck: !0, + }, + l = this.configuration.getLinkers(), + u = { project: this, report: t }, + h = new Map( + l.map((e) => { + const t = e.makeInstaller(u), + r = t.getCustomDataKey(), + A = this.installersCustomData.get(r); + return void 0 !== A && t.attachCustomData(A), [e, t]; + }) + ), + p = new Map(), + d = new Map(), + C = new Map(), + f = new Map( + await Promise.all( + [...this.accessibleLocators].map(async (e) => { + const t = this.storedPackages.get(e); + if (!t) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + return [e, await c.fetch(t, g)]; + }) + ) + ); + for (const e of this.accessibleLocators) { + const t = this.storedPackages.get(e); + if (void 0 === t) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + const r = f.get(t.locatorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: The fetch result should have been registered' + ); + const A = this.tryWorkspaceByLocator(t); + if (null !== A) { + const e = [], + { scripts: o } = A.manifest; + for (const t of ['preinstall', 'install', 'postinstall']) + o.has(t) && e.push([L.k.SCRIPT, t]); + try { + for (const e of h.values()) { + if (null !== (await e.installPackage(t, r)).buildDirective) + throw new Error( + "Assertion failed: Linkers can't return build directives for workspaces; this responsibility befalls to the Yarn core" + ); + } + } finally { + r.releaseFs && r.releaseFs(); + } + const i = n.y1.join(r.packageFs.getRealPath(), r.prefixPath); + d.set(t.locatorHash, i), + e.length > 0 && + C.set(t.locatorHash, { + directives: e, + buildLocations: [i], + }); + } else { + const e = l.find((e) => e.supportsPackage(t, u)); + if (!e) + throw new H.lk( + P.b.LINKER_NOT_FOUND, + O.prettyLocator(this.configuration, t) + + " isn't supported by any available linker" + ); + const A = h.get(e); + if (!A) + throw new Error( + 'Assertion failed: The installer should have been registered' + ); + let n; + try { + n = await A.installPackage(t, r); + } finally { + r.releaseFs && r.releaseFs(); + } + p.set(t.locatorHash, e), + d.set(t.locatorHash, n.packageLocation), + n.buildDirective && + n.packageLocation && + C.set(t.locatorHash, { + directives: n.buildDirective, + buildLocations: [n.packageLocation], + }); + } + } + const I = new Map(); + for (const e of this.accessibleLocators) { + const t = this.storedPackages.get(e); + if (!t) + throw new Error( + 'Assertion failed: The locator should have been registered' + ); + const r = null !== this.tryWorkspaceByLocator(t), + A = async (e, A) => { + const n = d.get(t.locatorHash); + if (void 0 === n) + throw new Error( + `Assertion failed: The package (${O.prettyLocator( + this.configuration, + t + )}) should have been registered` + ); + const o = []; + for (const A of t.dependencies.values()) { + const i = this.storedResolutions.get(A.descriptorHash); + if (void 0 === i) + throw new Error( + `Assertion failed: The resolution (${O.prettyDescriptor( + this.configuration, + A + )}, from ${O.prettyLocator( + this.configuration, + t + )})should have been registered` + ); + const s = this.storedPackages.get(i); + if (void 0 === s) + throw new Error( + `Assertion failed: The package (${i}, resolved from ${O.prettyDescriptor( + this.configuration, + A + )}) should have been registered` + ); + const a = + null === this.tryWorkspaceByLocator(s) ? p.get(i) : null; + if (void 0 === a) + throw new Error( + `Assertion failed: The package (${i}, resolved from ${O.prettyDescriptor( + this.configuration, + A + )}) should have been registered` + ); + const c = null === a; + if (a === e || r || c) + null !== d.get(s.locatorHash) && o.push([A, s]); + else if (null !== n) { + _.getArrayWithDefault(I, i).push(n); + } + } + null !== n && (await A.attachInternalDependencies(t, o)); + }; + if (r) for (const [e, t] of h) await A(e, t); + else { + const e = p.get(t.locatorHash); + if (!e) + throw new Error( + 'Assertion failed: The linker should have been found' + ); + const r = h.get(e); + if (!r) + throw new Error( + 'Assertion failed: The installer should have been registered' + ); + await A(e, r); + } + } + for (const [e, t] of I) { + const r = this.storedPackages.get(e); + if (!r) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + const A = p.get(r.locatorHash); + if (!A) + throw new Error( + 'Assertion failed: The linker should have been found' + ); + const n = h.get(A); + if (!n) + throw new Error( + 'Assertion failed: The installer should have been registered' + ); + await n.attachExternalDependents(r, t); + } + const E = new Map(); + for (const e of h.values()) { + const t = await e.finalizeInstall(); + for (const e of null !== (s = null == t ? void 0 : t.records) && + void 0 !== s + ? s + : []) + C.set(e.locatorHash, { + directives: e.buildDirective, + buildLocations: e.buildLocations, + }); + void 0 !== (null == t ? void 0 : t.customData) && + E.set(e.getCustomDataKey(), t.customData); + } + if ( + ((this.installersCustomData = E), + await this.persistInstallStateFile(), + o) + ) + return; + const B = new Set(this.storedPackages.keys()), + y = new Set(C.keys()); + for (const e of y) B.delete(e); + const m = (0, a.createHash)('sha512'); + m.update(process.versions.node), + this.configuration.triggerHook( + (e) => e.globalHashGeneration, + this, + (e) => { + m.update('\0'), m.update(e); + } + ); + const w = m.digest('hex'), + Q = new Map(), + D = (e) => { + let t = Q.get(e.locatorHash); + if (void 0 !== t) return t; + const r = this.storedPackages.get(e.locatorHash); + if (void 0 === r) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + const A = (0, a.createHash)('sha512'); + A.update(e.locatorHash), Q.set(e.locatorHash, ''); + for (const e of r.dependencies.values()) { + const t = this.storedResolutions.get(e.descriptorHash); + if (void 0 === t) + throw new Error( + `Assertion failed: The resolution (${O.prettyDescriptor( + this.configuration, + e + )}) should have been registered` + ); + const r = this.storedPackages.get(t); + if (void 0 === r) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + A.update(D(r)); + } + return (t = A.digest('hex')), Q.set(e.locatorHash, t), t; + }, + b = (e, t) => { + const r = (0, a.createHash)('sha512'); + r.update(w), r.update(D(e)); + for (const e of t) r.update(e); + return r.digest('hex'); + }, + v = this.configuration.get('bstatePath'), + S = A.xfs.existsSync(v) + ? (0, i.parseSyml)(await A.xfs.readFilePromise(v, 'utf8')) + : {}, + k = new Map(); + for (; y.size > 0; ) { + const e = y.size, + r = []; + for (const e of y) { + const o = this.storedPackages.get(e); + if (!o) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + let i = !0; + for (const e of o.dependencies.values()) { + const t = this.storedResolutions.get(e.descriptorHash); + if (!t) + throw new Error( + `Assertion failed: The resolution (${O.prettyDescriptor( + this.configuration, + e + )}) should have been registered` + ); + if (y.has(t)) { + i = !1; + break; + } + } + if (!i) continue; + y.delete(e); + const s = C.get(o.locatorHash); + if (!s) + throw new Error( + 'Assertion failed: The build directive should have been registered' + ); + const a = b(o, s.buildLocations); + if ( + Object.prototype.hasOwnProperty.call(S, o.locatorHash) && + S[o.locatorHash] === a + ) + k.set(o.locatorHash, a); + else { + Object.prototype.hasOwnProperty.call(S, o.locatorHash) + ? t.reportInfo( + P.b.MUST_REBUILD, + O.prettyLocator(this.configuration, o) + + ' must be rebuilt because its dependency tree changed' + ) + : t.reportInfo( + P.b.MUST_BUILD, + O.prettyLocator(this.configuration, o) + + ' must be built because it never did before or the last one failed' + ); + for (const e of s.buildLocations) { + if (!n.y1.isAbsolute(e)) + throw new Error( + `Assertion failed: Expected the build location to be absolute (not ${e})` + ); + r.push( + (async () => { + for (const [r, i] of s.directives) { + let s = `# This file contains the result of Yarn building a package (${O.stringifyLocator( + o + )})\n`; + switch (r) { + case L.k.SCRIPT: + s += `# Script name: ${i}\n`; + break; + case L.k.SHELLCODE: + s += `# Script code: ${i}\n`; + } + const c = null; + await A.xfs.mktempPromise(async (g) => { + const l = n.y1.join(g, 'build.log'), + { + stdout: u, + stderr: h, + } = this.configuration.getSubprocessStreams(l, { + header: s, + prefix: O.prettyLocator(this.configuration, o), + report: t, + }); + let p; + try { + switch (r) { + case L.k.SCRIPT: + p = await Z.executePackageScript(o, i, [], { + cwd: e, + project: this, + stdin: c, + stdout: u, + stderr: h, + }); + break; + case L.k.SHELLCODE: + p = await Z.executePackageShellcode( + o, + i, + [], + { + cwd: e, + project: this, + stdin: c, + stdout: u, + stderr: h, + } + ); + } + } catch (e) { + h.write(e.stack), (p = 1); + } + if ((u.end(), h.end(), 0 === p)) + return k.set(o.locatorHash, a), !0; + A.xfs.detachTemp(g); + const d = `${O.prettyLocator( + this.configuration, + o + )} couldn't be built successfully (exit code ${V.pretty( + this.configuration, + p, + V.Type.NUMBER + )}, logs can be found here: ${V.pretty( + this.configuration, + l, + V.Type.PATH + )})`; + return ( + t.reportInfo(P.b.BUILD_FAILED, d), + this.optionalBuilds.has(o.locatorHash) + ? (k.set(o.locatorHash, a), !0) + : (t.reportError(P.b.BUILD_FAILED, d), !1) + ); + }); + } + })() + ); + } + } + } + if ((await Promise.all(r), e === y.size)) { + const e = Array.from(y) + .map((e) => { + const t = this.storedPackages.get(e); + if (!t) + throw new Error( + 'Assertion failed: The package should have been registered' + ); + return O.prettyLocator(this.configuration, t); + }) + .join(', '); + t.reportError( + P.b.CYCLIC_DEPENDENCIES, + `Some packages have circular dependencies that make their build order unsatisfiable - as a result they won't be built (affected packages are: ${e})` + ); + break; + } + } + if (k.size > 0) { + const e = this.configuration.get('bstatePath'), + t = ie.generateBuildStateFile(k, this.storedPackages); + await A.xfs.mkdirPromise(n.y1.dirname(e), { recursive: !0 }), + await A.xfs.changeFilePromise(e, t, { automaticNewlines: !0 }); + } else await A.xfs.removePromise(v); + } + async install(e) { + var t, r; + const i = this.configuration.get('nodeLinker'); + null === (t = x.VK.telemetry) || void 0 === t || t.reportInstall(i), + await e.report.startTimerPromise( + 'Project validation', + { skipIfEmpty: !0 }, + async () => { + await this.configuration.triggerHook( + (e) => e.validateProject, + this, + { + reportWarning: e.report.reportWarning.bind(e.report), + reportError: e.report.reportError.bind(e.report), + } + ); + } + ); + for (const e of this.configuration.packageExtensions.values()) + for (const [, t] of e) + for (const e of t) e.status = ee._u.Inactive; + const s = n.y1.join( + this.cwd, + this.configuration.get('lockfileFilename') + ); + let a = null; + if (e.immutable) + try { + a = await A.xfs.readFilePromise(s, 'utf8'); + } catch (e) { + throw 'ENOENT' === e.code + ? new H.lk( + P.b.FROZEN_LOCKFILE_EXCEPTION, + 'The lockfile would have been created by this install, which is explicitly forbidden.' + ) + : e; + } + await e.report.startTimerPromise('Resolution step', async () => { + await this.resolveEverything(e); + }), + await e.report.startTimerPromise( + 'Post-resolution validation', + { skipIfEmpty: !0 }, + async () => { + for (const [, t] of this.configuration.packageExtensions) + for (const [, r] of t) + for (const t of r) + if (t.userProvided) { + const r = V.pretty( + this.configuration, + t, + V.Type.PACKAGE_EXTENSION + ); + switch (t.status) { + case ee._u.Inactive: + e.report.reportWarning( + P.b.UNUSED_PACKAGE_EXTENSION, + r + + ': No matching package in the dependency tree; you may not need this rule anymore.' + ); + break; + case ee._u.Redundant: + e.report.reportWarning( + P.b.REDUNDANT_PACKAGE_EXTENSION, + r + + ': This rule seems redundant when applied on the original package; the extension may have been applied upstream.' + ); + } + } + if (null !== a) { + const t = (0, o.qH)(a, this.generateLockfile()); + if (t !== a) { + const r = w(s, s, a, t); + e.report.reportSeparator(); + for (const t of r.hunks) { + e.report.reportInfo( + null, + `@@ -${t.oldStart},${t.oldLines} +${t.newStart},${t.newLines} @@` + ); + for (const r of t.lines) + r.startsWith('+') + ? e.report.reportError( + P.b.FROZEN_LOCKFILE_EXCEPTION, + V.pretty(this.configuration, r, V.Type.ADDED) + ) + : r.startsWith('-') + ? e.report.reportError( + P.b.FROZEN_LOCKFILE_EXCEPTION, + V.pretty(this.configuration, r, V.Type.REMOVED) + ) + : e.report.reportInfo( + null, + V.pretty(this.configuration, r, 'grey') + ); + } + throw ( + (e.report.reportSeparator(), + new H.lk( + P.b.FROZEN_LOCKFILE_EXCEPTION, + 'The lockfile would have been modified by this install, which is explicitly forbidden.' + )) + ); + } + } + } + ); + for (const e of this.configuration.packageExtensions.values()) + for (const [, t] of e) + for (const e of t) + e.userProvided && + e.status === ee._u.Active && + (null === (r = x.VK.telemetry) || + void 0 === r || + r.reportPackageExtension( + V.json(e, V.Type.PACKAGE_EXTENSION) + )); + await e.report.startTimerPromise('Fetch step', async () => { + await this.fetchEverything(e), + (void 0 === e.persistProject || e.persistProject) && + (await this.cacheCleanup(e)); + }), + (void 0 === e.persistProject || e.persistProject) && + (await this.persist()), + await e.report.startTimerPromise('Link step', async () => { + const t = e.immutable + ? [ + ...new Set(this.configuration.get('immutablePatterns')), + ].sort() + : [], + r = await Promise.all( + t.map(async (e) => X.checksumPattern(e, { cwd: this.cwd })) + ); + await this.linkEverything(e); + const A = await Promise.all( + t.map(async (e) => X.checksumPattern(e, { cwd: this.cwd })) + ); + for (let n = 0; n < t.length; ++n) + r[n] !== A[n] && + e.report.reportError( + P.b.FROZEN_ARTIFACT_EXCEPTION, + `The checksum for ${t[n]} has been modified by this install, which is explicitly forbidden.` + ); + }), + await this.persistInstallStateFile(), + await this.configuration.triggerHook( + (e) => e.afterAllInstalled, + this, + e + ); + } + generateLockfile() { + const e = new Map(); + for (const [t, r] of this.storedResolutions.entries()) { + let A = e.get(r); + A || e.set(r, (A = new Set())), A.add(t); + } + const t = { __metadata: { version: 4 } }; + for (const [r, A] of e.entries()) { + const e = this.originalPackages.get(r); + if (!e) continue; + const n = []; + for (const e of A) { + const t = this.storedDescriptors.get(e); + if (!t) + throw new Error( + 'Assertion failed: The descriptor should have been registered' + ); + n.push(t); + } + const o = n + .map((e) => O.stringifyDescriptor(e)) + .sort() + .join(', '), + i = new Y.G(); + let s; + (i.version = + e.linkType === ee.Un.HARD ? e.version : '0.0.0-use.local'), + (i.languageName = e.languageName), + (i.dependencies = new Map(e.dependencies)), + (i.peerDependencies = new Map(e.peerDependencies)), + (i.dependenciesMeta = new Map(e.dependenciesMeta)), + (i.peerDependenciesMeta = new Map(e.peerDependenciesMeta)), + (i.bin = new Map(e.bin)); + const a = this.storedChecksums.get(e.locatorHash); + if (void 0 !== a) { + const e = a.indexOf('/'); + if (-1 === e) + throw new Error( + 'Assertion failed: Expecte the checksum to reference its cache key' + ); + const r = a.slice(0, e), + A = a.slice(e + 1); + void 0 === t.__metadata.cacheKey && (t.__metadata.cacheKey = r), + (s = r === t.__metadata.cacheKey ? A : a); + } + t[o] = { + ...i.exportTo({}, { compatibilityMode: !1 }), + linkType: e.linkType.toLowerCase(), + resolution: O.stringifyLocator(e), + checksum: s, + }; + } + return ( + [ + '# This file is generated by running "yarn install" inside your project.\n', + '# Manual changes might be lost - proceed with caution!\n', + ].join('') + + '\n' + + (0, i.stringifySyml)(t) + ); + } + async persistLockfile() { + const e = n.y1.join( + this.cwd, + this.configuration.get('lockfileFilename') + ), + t = this.generateLockfile(); + await A.xfs.changeFilePromise(e, t, { automaticNewlines: !0 }); + } + async persistInstallStateFile() { + const e = []; + for (const t of Object.values(oe)) e.push(...t); + const t = D()(this, e), + r = await Ae(K().serialize(t)), + o = this.configuration.get('installStatePath'); + await A.xfs.mkdirPromise(n.y1.dirname(o), { recursive: !0 }), + await A.xfs.changeFilePromise(o, r); + } + async restoreInstallState({ + restoreInstallersCustomData: e = !0, + restoreResolutions: t = !0, + } = {}) { + const r = this.configuration.get('installStatePath'); + if (!A.xfs.existsSync(r)) + return void (t && (await this.applyLightResolution())); + const n = await A.xfs.readFilePromise(r), + o = K().deserialize(await ne(n)); + e && + void 0 !== o.installersCustomData && + (this.installersCustomData = o.installersCustomData), + t && + (o.lockFileChecksum === this.lockFileChecksum + ? (Object.assign(this, D()(o, oe.restoreResolutions)), + this.refreshWorkspaceDependencies()) + : await this.applyLightResolution()); + } + async applyLightResolution() { + await this.resolveEverything({ + lockfileOnly: !0, + report: new q.$(), + }), + await this.persistInstallStateFile(); + } + async persist() { + await this.persistLockfile(); + for (const e of this.workspacesByCwd.values()) + await e.persistManifest(); + } + async cacheCleanup({ cache: e, report: t }) { + const r = new Set(['.gitignore']); + if ( + A.xfs.existsSync(e.cwd) && + (0, W.isFolderInside)(e.cwd, this.cwd) + ) { + for (const o of await A.xfs.readdirPromise(e.cwd)) { + if (r.has(o)) continue; + const i = n.y1.resolve(e.cwd, o); + e.markedFiles.has(i) || + (e.immutable + ? t.reportError( + P.b.IMMUTABLE_CACHE, + V.pretty( + this.configuration, + n.y1.basename(i), + 'magenta' + ) + + ' appears to be unused and would marked for deletion, but the cache is immutable' + ) + : (t.reportInfo( + P.b.UNUSED_CACHE_ENTRY, + V.pretty( + this.configuration, + n.y1.basename(i), + 'magenta' + ) + ' appears to be unused - removing' + ), + await A.xfs.removePromise(i))); + } + e.markedFiles.clear(); + } + } + } + }, + 52779: (e, t, r) => { + 'use strict'; + r.d(t, { c: () => s, O: () => a }); + var A = r(53887), + n = r.n(A), + o = r(36545), + i = r(54143); + const s = /^(?!v)[a-z0-9-.]+$/i; + class a { + supportsDescriptor(e, t) { + return !!o.validRange(e.range) || !!s.test(e.range); + } + supportsLocator(e, t) { + return !!n().valid(e.reference) || !!s.test(e.reference); + } + shouldPersistResolution(e, t) { + return t.resolver.shouldPersistResolution( + this.forwardLocator(e, t), + t + ); + } + bindDescriptor(e, t, r) { + return r.resolver.bindDescriptor( + this.forwardDescriptor(e, r), + t, + r + ); + } + getResolutionDependencies(e, t) { + return t.resolver.getResolutionDependencies( + this.forwardDescriptor(e, t), + t + ); + } + async getCandidates(e, t, r) { + return await r.resolver.getCandidates( + this.forwardDescriptor(e, r), + t, + r + ); + } + async getSatisfying(e, t, r) { + return await r.resolver.getSatisfying( + this.forwardDescriptor(e, r), + t, + r + ); + } + async resolve(e, t) { + const r = await t.resolver.resolve(this.forwardLocator(e, t), t); + return i.renamePackage(r, e); + } + forwardDescriptor(e, t) { + return i.makeDescriptor( + e, + `${t.project.configuration.get('defaultProtocol')}${e.range}` + ); + } + forwardLocator(e, t) { + return i.makeLocator( + e, + `${t.project.configuration.get('defaultProtocol')}${e.reference}` + ); + } + } + }, + 35691: (e, t, r) => { + 'use strict'; + r.d(t, { lk: () => i, yG: () => s }); + var A = r(92413), + n = r(24304), + o = r(92659); + class i extends Error { + constructor(e, t, r) { + super(t), (this.reportExtra = r), (this.reportCode = e); + } + } + class s { + constructor() { + (this.reportedInfos = new Set()), + (this.reportedWarnings = new Set()), + (this.reportedErrors = new Set()); + } + static progressViaCounter(e) { + let t, + r = 0, + A = new Promise((e) => { + t = e; + }); + const n = (e) => { + const n = t; + (A = new Promise((e) => { + t = e; + })), + (r = e), + n(); + }, + o = (async function* () { + for (; r < e; ) await A, yield { progress: r / e }; + })(); + return { + [Symbol.asyncIterator]: () => o, + set: n, + tick: (e = 0) => { + n(r + 1); + }, + }; + } + reportInfoOnce(e, t, r) { + const A = r && r.key ? r.key : t; + this.reportedInfos.has(A) || + (this.reportedInfos.add(A), this.reportInfo(e, t)); + } + reportWarningOnce(e, t, r) { + const A = r && r.key ? r.key : t; + this.reportedWarnings.has(A) || + (this.reportedWarnings.add(A), this.reportWarning(e, t)); + } + reportErrorOnce(e, t, r) { + var A; + const n = r && r.key ? r.key : t; + this.reportedErrors.has(n) || + (this.reportedErrors.add(n), + this.reportError(e, t), + null === (A = null == r ? void 0 : r.reportExtra) || + void 0 === A || + A.call(r, this)); + } + reportExceptionOnce(e) { + !(function (e) { + return void 0 !== e.reportCode; + })(e) + ? this.reportErrorOnce(o.b.EXCEPTION, e.stack || e.message, { + key: e, + }) + : this.reportErrorOnce(e.reportCode, e.message, { + key: e, + reportExtra: e.reportExtra, + }); + } + createStreamReporter(e = null) { + const t = new A.PassThrough(), + r = new n.StringDecoder(); + let o = ''; + return ( + t.on('data', (t) => { + let A, + n = r.write(t); + do { + if (((A = n.indexOf('\n')), -1 !== A)) { + const t = o + n.substr(0, A); + (n = n.substr(A + 1)), + (o = ''), + null !== e + ? this.reportInfo(null, `${e} ${t}`) + : this.reportInfo(null, t); + } + } while (-1 !== A); + o += n; + }), + t.on('end', () => { + const t = r.end(); + '' !== t && + (null !== e + ? this.reportInfo(null, `${e} ${t}`) + : this.reportInfo(null, t)); + }), + t + ); + } + } + }, + 15815: (e, t, r) => { + 'use strict'; + r.d(t, { Qw: () => C, Pk: () => f }); + var A = r(29148), + n = r.n(A), + o = r(92659), + i = r(35691), + s = r(71643); + const a = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'], + c = new Set([o.b.FETCH_NOT_CACHED, o.b.UNUSED_CACHE_ENTRY]), + g = process.env.GITHUB_ACTIONS + ? { start: (e) => `::group::${e}\n`, end: (e) => '::endgroup::\n' } + : process.env.TRAVIS + ? { + start: (e) => `travis_fold:start:${e}\n`, + end: (e) => `travis_fold:end:${e}\n`, + } + : process.env.GITLAB_CI + ? { + start: (e) => + `section_start:${Math.floor( + Date.now() / 1e3 + )}:${e.toLowerCase().replace(/\W+/g, '_')}\r${e}\n`, + end: (e) => + `section_end:${Math.floor( + Date.now() / 1e3 + )}:${e.toLowerCase().replace(/\W+/g, '_')}\r`, + } + : null, + l = new Date(), + u = + ['iTerm.app', 'Apple_Terminal'].includes( + process.env.TERM_PROGRAM + ) || !!process.env.WT_SESSION, + h = { + patrick: { date: [17, 3], chars: ['🍀', '🌱'], size: 40 }, + simba: { date: [19, 7], chars: ['🦁', '🌴'], size: 40 }, + jack: { date: [31, 10], chars: ['🎃', '🦇'], size: 40 }, + hogsfather: { date: [31, 12], chars: ['🎉', '🎄'], size: 40 }, + default: { chars: ['=', '-'], size: 80 }, + }, + p = + (u && + Object.keys(h).find((e) => { + const t = h[e]; + return ( + !t.date || + (t.date[0] === l.getDate() && t.date[1] === l.getMonth() + 1) + ); + })) || + 'default'; + function d(e, { configuration: t, json: r }) { + const A = null === e ? 0 : e, + n = (0, o.i)(A); + return r || null !== e ? n : s.pretty(t, n, 'grey'); + } + function C(e, { configuration: t, json: r }) { + const A = d(e, { configuration: t, json: r }); + if (!t.get('enableHyperlinks')) return A; + if (null === e || e === o.b.UNNAMED) return A; + return `]8;;${`https://yarnpkg.com/advanced/error-codes#${A}---${o.b[e]}`.toLowerCase()}${A}]8;;`; + } + class f extends i.yG { + constructor({ + configuration: e, + stdout: t, + json: r = !1, + includeFooter: A = !0, + includeLogs: n = !r, + includeInfos: o = n, + includeWarnings: i = n, + forgettableBufferSize: a = 5, + forgettableNames: g = new Set(), + }) { + super(), + (this.uncommitted = new Set()), + (this.cacheHitCount = 0), + (this.cacheMissCount = 0), + (this.warningCount = 0), + (this.errorCount = 0), + (this.startTime = Date.now()), + (this.indent = 0), + (this.progress = new Map()), + (this.progressTime = 0), + (this.progressFrame = 0), + (this.progressTimeout = null), + (this.forgettableLines = []), + s.addLogFilterSupport(this, { configuration: e }), + (this.configuration = e), + (this.forgettableBufferSize = a), + (this.forgettableNames = new Set([...g, ...c])), + (this.includeFooter = A), + (this.includeInfos = o), + (this.includeWarnings = i), + (this.json = r), + (this.stdout = t); + const l = this.configuration.get('progressBarStyle') || p; + if (!Object.prototype.hasOwnProperty.call(h, l)) + throw new Error('Assertion failed: Invalid progress bar style'); + this.progressStyle = h[l]; + const u = '➤ YN0000: ┌ '.length, + d = Math.max(0, Math.min(process.stdout.columns - u, 80)); + this.progressMaxScaledSize = Math.floor( + (this.progressStyle.size * d) / 80 + ); + } + static async start(e, t) { + const r = new this(e), + A = process.emitWarning; + process.emitWarning = (e, t) => { + if ('string' != typeof e) { + const r = e; + (e = r.message), (t = null != t ? t : r.name); + } + const A = void 0 !== t ? `${t}: ${e}` : e; + r.reportWarning(o.b.UNNAMED, A); + }; + try { + await t(r); + } catch (e) { + r.reportExceptionOnce(e); + } finally { + await r.finalize(), (process.emitWarning = A); + } + return r; + } + hasErrors() { + return this.errorCount > 0; + } + exitCode() { + return this.hasErrors() ? 1 : 0; + } + reportCacheHit(e) { + this.cacheHitCount += 1; + } + reportCacheMiss(e, t) { + (this.cacheMissCount += 1), + void 0 === t || + this.configuration.get('preferAggregateCacheInfo') || + this.reportInfo(o.b.FETCH_NOT_CACHED, t); + } + startTimerSync(e, t, r) { + const A = 'function' == typeof t ? t : r, + n = { + committed: !1, + action: () => { + this.reportInfo(null, '┌ ' + e), + (this.indent += 1), + null !== g && this.stdout.write(g.start(e)); + }, + }; + ('function' == typeof t ? {} : t).skipIfEmpty + ? this.uncommitted.add(n) + : (n.action(), (n.committed = !0)); + const o = Date.now(); + try { + return A(); + } catch (e) { + throw (this.reportExceptionOnce(e), e); + } finally { + const t = Date.now(); + this.uncommitted.delete(n), + n.committed && + ((this.indent -= 1), + null !== g && this.stdout.write(g.end(e)), + this.configuration.get('enableTimers') && t - o > 200 + ? this.reportInfo( + null, + '└ Completed in ' + + s.pretty(this.configuration, t - o, s.Type.DURATION) + ) + : this.reportInfo(null, '└ Completed')); + } + } + async startTimerPromise(e, t, r) { + const A = 'function' == typeof t ? t : r, + n = { + committed: !1, + action: () => { + this.reportInfo(null, '┌ ' + e), + (this.indent += 1), + null !== g && this.stdout.write(g.start(e)); + }, + }; + ('function' == typeof t ? {} : t).skipIfEmpty + ? this.uncommitted.add(n) + : (n.action(), (n.committed = !0)); + const o = Date.now(); + try { + return await A(); + } catch (e) { + throw (this.reportExceptionOnce(e), e); + } finally { + const t = Date.now(); + this.uncommitted.delete(n), + n.committed && + ((this.indent -= 1), + null !== g && this.stdout.write(g.end(e)), + this.configuration.get('enableTimers') && t - o > 200 + ? this.reportInfo( + null, + '└ Completed in ' + + s.pretty(this.configuration, t - o, s.Type.DURATION) + ) + : this.reportInfo(null, '└ Completed')); + } + } + async startCacheReport(e) { + const t = this.configuration.get('preferAggregateCacheInfo') + ? { + cacheHitCount: this.cacheHitCount, + cacheMissCount: this.cacheMissCount, + } + : null; + try { + return await e(); + } catch (e) { + throw (this.reportExceptionOnce(e), e); + } finally { + null !== t && this.reportCacheChanges(t); + } + } + reportSeparator() { + 0 === this.indent + ? this.writeLineWithForgettableReset('') + : this.reportInfo(null, ''); + } + reportInfo(e, t) { + if (!this.includeInfos) return; + this.commit(); + const r = `${s.pretty( + this.configuration, + '➤', + 'blueBright' + )} ${this.formatNameWithHyperlink(e)}: ${this.formatIndent()}${t}`; + if (this.json) + this.reportJson({ + type: 'info', + name: e, + displayName: this.formatName(e), + indent: this.formatIndent(), + data: t, + }); + else if (this.forgettableNames.has(e)) + if ( + (this.forgettableLines.push(r), + this.forgettableLines.length > this.forgettableBufferSize) + ) { + for ( + ; + this.forgettableLines.length > this.forgettableBufferSize; + + ) + this.forgettableLines.shift(); + this.writeLines(this.forgettableLines, { truncate: !0 }); + } else this.writeLine(r, { truncate: !0 }); + else this.writeLineWithForgettableReset(r); + } + reportWarning(e, t) { + (this.warningCount += 1), + this.includeWarnings && + (this.commit(), + this.json + ? this.reportJson({ + type: 'warning', + name: e, + displayName: this.formatName(e), + indent: this.formatIndent(), + data: t, + }) + : this.writeLineWithForgettableReset( + `${s.pretty( + this.configuration, + '➤', + 'yellowBright' + )} ${this.formatNameWithHyperlink( + e + )}: ${this.formatIndent()}${t}` + )); + } + reportError(e, t) { + (this.errorCount += 1), + this.commit(), + this.json + ? this.reportJson({ + type: 'error', + name: e, + displayName: this.formatName(e), + indent: this.formatIndent(), + data: t, + }) + : this.writeLineWithForgettableReset( + `${s.pretty( + this.configuration, + '➤', + 'redBright' + )} ${this.formatNameWithHyperlink( + e + )}: ${this.formatIndent()}${t}`, + { truncate: !1 } + ); + } + reportProgress(e) { + let t = !1; + const r = Promise.resolve().then(async () => { + const r = { progress: 0, title: void 0 }; + this.progress.set(e, { definition: r, lastScaledSize: -1 }), + this.refreshProgress(-1); + for await (const { progress: A, title: n } of e) + t || + (r.progress === A && r.title === n) || + ((r.progress = A), (r.title = n), this.refreshProgress()); + A(); + }), + A = () => { + t || + ((t = !0), this.progress.delete(e), this.refreshProgress(1)); + }; + return { ...r, stop: A }; + } + reportJson(e) { + this.json && + this.writeLineWithForgettableReset('' + JSON.stringify(e)); + } + async finalize() { + if (!this.includeFooter) return; + let e = ''; + e = + this.errorCount > 0 + ? 'Failed with errors' + : this.warningCount > 0 + ? 'Done with warnings' + : 'Done'; + const t = s.pretty( + this.configuration, + Date.now() - this.startTime, + s.Type.DURATION + ), + r = this.configuration.get('enableTimers') ? `${e} in ${t}` : e; + this.errorCount > 0 + ? this.reportError(o.b.UNNAMED, r) + : this.warningCount > 0 + ? this.reportWarning(o.b.UNNAMED, r) + : this.reportInfo(o.b.UNNAMED, r); + } + writeLine(e, { truncate: t } = {}) { + this.clearProgress({ clear: !0 }), + this.stdout.write(this.truncate(e, { truncate: t }) + '\n'), + this.writeProgress(); + } + writeLineWithForgettableReset(e, { truncate: t } = {}) { + (this.forgettableLines = []), this.writeLine(e, { truncate: t }); + } + writeLines(e, { truncate: t } = {}) { + this.clearProgress({ delta: e.length }); + for (const r of e) + this.stdout.write(this.truncate(r, { truncate: t }) + '\n'); + this.writeProgress(); + } + reportCacheChanges({ cacheHitCount: e, cacheMissCount: t }) { + const r = this.cacheHitCount - e, + A = this.cacheMissCount - t; + if (0 === r && 0 === A) return; + let n = ''; + this.cacheHitCount > 1 + ? (n += this.cacheHitCount + ' packages were already cached') + : 1 === this.cacheHitCount + ? (n += ' - one package was already cached') + : (n += 'No packages were cached'), + this.cacheHitCount > 0 + ? this.cacheMissCount > 1 + ? (n += `, ${this.cacheMissCount} had to be fetched`) + : 1 === this.cacheMissCount && + (n += ', one had to be fetched') + : this.cacheMissCount > 1 + ? (n += ` - ${this.cacheMissCount} packages had to be fetched`) + : 1 === this.cacheMissCount && + (n += ' - one package had to be fetched'), + this.reportInfo(o.b.FETCH_NOT_CACHED, n); + } + commit() { + const e = this.uncommitted; + this.uncommitted = new Set(); + for (const t of e) (t.committed = !0), t.action(); + } + clearProgress({ delta: e = 0, clear: t = !1 }) { + this.configuration.get('enableProgressBars') && + !this.json && + this.progress.size + e > 0 && + (this.stdout.write(`[${this.progress.size + e}A`), + (e > 0 || t) && this.stdout.write('')); + } + writeProgress() { + if (!this.configuration.get('enableProgressBars') || this.json) + return; + if ( + (null !== this.progressTimeout && + clearTimeout(this.progressTimeout), + (this.progressTimeout = null), + 0 === this.progress.size) + ) + return; + const e = Date.now(); + e - this.progressTime > 80 && + ((this.progressFrame = (this.progressFrame + 1) % a.length), + (this.progressTime = e)); + const t = a[this.progressFrame]; + for (const e of this.progress.values()) { + const r = this.progressStyle.chars[0].repeat(e.lastScaledSize), + A = this.progressStyle.chars[1].repeat( + this.progressMaxScaledSize - e.lastScaledSize + ); + this.stdout.write( + `${s.pretty( + this.configuration, + '➤', + 'blueBright' + )} ${this.formatName(null)}: ${t} ${r}${A}\n` + ); + } + this.progressTimeout = setTimeout(() => { + this.refreshProgress(); + }, 80); + } + refreshProgress(e = 0) { + let t = !1; + if (0 === this.progress.size) t = !0; + else + for (const e of this.progress.values()) { + const r = Math.trunc( + this.progressMaxScaledSize * e.definition.progress + ), + A = e.lastScaledSize; + if (((e.lastScaledSize = r), r !== A)) { + t = !0; + break; + } + } + t && (this.clearProgress({ delta: e }), this.writeProgress()); + } + truncate(e, { truncate: t } = {}) { + return ( + this.configuration.get('enableProgressBars') || (t = !1), + void 0 === t && + (t = this.configuration.get('preferTruncatedLines')), + t && (e = n()(e, 0, process.stdout.columns - 1)), + e + ); + } + formatName(e) { + return d(e, { configuration: this.configuration, json: this.json }); + } + formatNameWithHyperlink(e) { + return C(e, { configuration: this.configuration, json: this.json }); + } + formatIndent() { + return '│ '.repeat(this.indent); + } + } + }, + 81832: (e, t, r) => { + 'use strict'; + r.d(t, { E: () => a }); + var A, + n = r(43896), + o = r(46009), + i = r(79669), + s = r(73632); + !(function (e) { + (e.VERSION = 'version'), + (e.COMMAND_NAME = 'commandName'), + (e.PLUGIN_NAME = 'pluginName'), + (e.INSTALL_COUNT = 'installCount'), + (e.PROJECT_COUNT = 'projectCount'), + (e.WORKSPACE_COUNT = 'workspaceCount'), + (e.DEPENDENCY_COUNT = 'dependencyCount'), + (e.EXTENSION = 'packageExtension'); + })(A || (A = {})); + class a { + constructor(e, t) { + (this.values = new Map()), + (this.hits = new Map()), + (this.enumerators = new Map()), + (this.configuration = e); + const r = this.getRegistryPath(); + (this.isNew = !n.xfs.existsSync(r)), + this.sendReport(t), + this.startBuffer(); + } + reportVersion(e) { + this.reportValue(A.VERSION, e); + } + reportCommandName(e) { + this.reportValue(A.COMMAND_NAME, e || ''); + } + reportPluginName(e) { + this.reportValue(A.PLUGIN_NAME, e); + } + reportProject(e) { + this.reportEnumerator(A.PROJECT_COUNT, e); + } + reportInstall(e) { + this.reportHit(A.INSTALL_COUNT, e); + } + reportPackageExtension(e) { + this.reportValue(A.EXTENSION, e); + } + reportWorkspaceCount(e) { + this.reportValue(A.WORKSPACE_COUNT, String(e)); + } + reportDependencyCount(e) { + this.reportValue(A.DEPENDENCY_COUNT, String(e)); + } + reportValue(e, t) { + s.getSetWithDefault(this.values, e).add(t); + } + reportEnumerator(e, t) { + s.getSetWithDefault(this.enumerators, e).add(t); + } + reportHit(e, t = '*') { + const r = s.getMapWithDefault(this.hits, e), + A = s.getFactoryWithDefault(r, t, () => 0); + r.set(t, A + 1); + } + getRegistryPath() { + const e = this.configuration.get('globalFolder'); + return o.y1.join(e, 'telemetry.json'); + } + sendReport(e) { + var t, r, A; + const s = this.getRegistryPath(); + let a; + try { + a = n.xfs.readJsonSync(s); + } catch (e) { + a = {}; + } + const c = Date.now(), + g = + 24 * + this.configuration.get('telemetryInterval') * + 60 * + 60 * + 1e3, + l = + (null !== (t = a.lastUpdate) && void 0 !== t + ? t + : c + g + Math.floor(g * Math.random())) + g; + if (!(l > c && null != a.lastUpdate)) { + try { + n.xfs.mkdirSync(o.y1.dirname(s), { recursive: !0 }), + n.xfs.writeJsonSync(s, { lastUpdate: c }); + } catch (e) { + return; + } + if (!(l > c) && a.blocks) + for (const [t, n] of Object.entries( + null !== (r = a.blocks) && void 0 !== r ? r : {} + )) { + if (0 === Object.keys(n).length) continue; + const r = n; + r.userId = t; + for (const e of Object.keys( + null !== (A = r.enumerators) && void 0 !== A ? A : {} + )) + r.enumerators[e] = r.enumerators[e].length; + const o = `https://browser-http-intake.logs.datadoghq.eu/v1/input/${e}?ddsource=yarn`; + i.post(o, r, { + configuration: this.configuration, + }).catch(() => {}); + } + } + } + applyChanges() { + var e, t, r, A, i, s, a, c, g; + const l = this.getRegistryPath(); + let u; + try { + u = n.xfs.readJsonSync(l); + } catch (e) { + u = {}; + } + const h = + null !== (e = this.configuration.get('telemetryUserId')) && + void 0 !== e + ? e + : '*', + p = (u.blocks = null !== (t = u.blocks) && void 0 !== t ? t : {}), + d = (p[h] = null !== (r = p[h]) && void 0 !== r ? r : {}); + for (const e of this.hits.keys()) { + const t = (d.hits = + null !== (A = d.hits) && void 0 !== A ? A : {}), + r = (t[e] = null !== (i = t[e]) && void 0 !== i ? i : {}); + for (const [t, A] of this.hits.get(e)) + r[t] = (null !== (s = r[t]) && void 0 !== s ? s : 0) + A; + } + for (const e of ['values', 'enumerators']) + for (const t of this[e].keys()) { + const r = (d[e] = null !== (a = d[e]) && void 0 !== a ? a : {}); + r[t] = [ + ...new Set([ + ...(null !== (c = r[t]) && void 0 !== c ? c : []), + ...(null !== (g = this[e].get(t)) && void 0 !== g ? g : []), + ]), + ]; + } + n.xfs.mkdirSync(o.y1.dirname(l), { recursive: !0 }), + n.xfs.writeJsonSync(l, u); + } + startBuffer() { + process.on('exit', () => { + try { + this.applyChanges(); + } catch (e) {} + }); + } + } + }, + 33720: (e, t, r) => { + 'use strict'; + r.d(t, { $: () => n }); + var A = r(35691); + class n extends A.yG { + reportCacheHit(e) {} + reportCacheMiss(e) {} + startTimerSync(e, t, r) { + return ('function' == typeof t ? t : r)(); + } + async startTimerPromise(e, t, r) { + const A = 'function' == typeof t ? t : r; + return await A(); + } + async startCacheReport(e) { + return await e(); + } + reportSeparator() {} + reportInfo(e, t) {} + reportWarning(e, t) {} + reportError(e, t) {} + reportProgress(e) { + return { + ...Promise.resolve().then(async () => { + for await (const {} of e); + }), + stop: () => {}, + }; + } + reportJson(e) {} + async finalize() {} + } + }, + 60895: (e, t, r) => { + 'use strict'; + r.d(t, { N: () => s }); + var A = r(17674), + n = r(14626), + o = r(46009), + i = r(54143); + class s { + supports(e) { + return !!e.reference.startsWith('virtual:'); + } + getLocalPath(e, t) { + const r = e.reference.indexOf('#'); + if (-1 === r) throw new Error('Invalid virtual package reference'); + const A = e.reference.slice(r + 1), + n = i.makeLocator(e, A); + return t.fetcher.getLocalPath(n, t); + } + async fetch(e, t) { + const r = e.reference.indexOf('#'); + if (-1 === r) throw new Error('Invalid virtual package reference'); + const A = e.reference.slice(r + 1), + n = i.makeLocator(e, A), + o = await t.fetcher.fetch(n, t); + return await this.ensureVirtualLink(e, o, t); + } + getLocatorFilename(e) { + return i.slugifyLocator(e); + } + async ensureVirtualLink(e, t, r) { + const i = t.packageFs.getRealPath(), + s = r.project.configuration.get('virtualFolder'), + a = this.getLocatorFilename(e), + c = A.p.makeVirtualPath(s, a, i), + g = new n.K(c, { baseFs: t.packageFs, pathUtils: o.y1 }); + return { ...t, packageFs: g }; + } + } + }, + 17722: (e, t, r) => { + 'use strict'; + r.d(t, { j: () => h }); + var A = r(43896), + n = r(46009), + o = r(58592), + i = r.n(o), + s = r(53887), + a = r.n(s), + c = r(46611), + g = r(94538), + l = r(20624), + u = r(54143); + class h { + constructor(e, { project: t }) { + (this.workspacesCwds = new Set()), + (this.dependencies = new Map()), + (this.project = t), + (this.cwd = e); + } + async setup() { + (this.manifest = A.xfs.existsSync(n.y1.join(this.cwd, c.G.fileName)) + ? await c.G.find(this.cwd) + : new c.G()), + (this.relativeCwd = + n.y1.relative(this.project.cwd, this.cwd) || n.LZ.dot); + const e = this.manifest.name + ? this.manifest.name + : u.makeIdent( + null, + `${this.computeCandidateName()}-${l + .makeHash(this.relativeCwd) + .substr(0, 6)}` + ), + t = this.manifest.version ? this.manifest.version : '0.0.0'; + (this.locator = u.makeLocator(e, t)), + (this.anchoredDescriptor = u.makeDescriptor( + this.locator, + `${g.d.protocol}${this.relativeCwd}` + )), + (this.anchoredLocator = u.makeLocator( + this.locator, + `${g.d.protocol}${this.relativeCwd}` + )); + const r = this.manifest.workspaceDefinitions.map( + ({ pattern: e }) => e + ), + o = await i()(r, { + absolute: !0, + cwd: n.cS.fromPortablePath(this.cwd), + expandDirectories: !1, + onlyDirectories: !0, + onlyFiles: !1, + ignore: ['**/node_modules', '**/.git', '**/.yarn'], + }); + o.sort(); + for (const e of o) { + const t = n.y1.resolve(this.cwd, n.cS.toPortablePath(e)); + A.xfs.existsSync(n.y1.join(t, 'package.json')) && + this.workspacesCwds.add(t); + } + } + accepts(e) { + const t = e.indexOf(':'), + r = -1 !== t ? e.slice(0, t + 1) : null, + A = -1 !== t ? e.slice(t + 1) : e; + return ( + (r === g.d.protocol && n.y1.normalize(A) === this.relativeCwd) || + (r === g.d.protocol && '*' === A) || + (!!a().validRange(A) && + (r === g.d.protocol + ? a().satisfies( + null !== this.manifest.version + ? this.manifest.version + : '0.0.0', + A + ) + : !!this.project.configuration.get( + 'enableTransparentWorkspaces' + ) && + null !== this.manifest.version && + a().satisfies(this.manifest.version, A))) + ); + } + computeCandidateName() { + return this.cwd === this.project.cwd + ? 'root-workspace' + : '' + n.y1.basename(this.cwd) || 'unnamed-workspace'; + } + async persistManifest() { + const e = {}; + this.manifest.exportTo(e); + const t = n.y1.join(this.cwd, c.G.fileName), + r = JSON.stringify(e, null, this.manifest.indent) + '\n'; + await A.xfs.changeFilePromise(t, r, { automaticNewlines: !0 }); + } + } + }, + 94538: (e, t, r) => { + 'use strict'; + r.d(t, { d: () => n }); + var A = r(32485); + class n { + supportsDescriptor(e, t) { + if (e.range.startsWith(n.protocol)) return !0; + return null !== t.project.tryWorkspaceByDescriptor(e); + } + supportsLocator(e, t) { + return !!e.reference.startsWith(n.protocol); + } + shouldPersistResolution(e, t) { + return !1; + } + bindDescriptor(e, t, r) { + return e; + } + getResolutionDependencies(e, t) { + return []; + } + async getCandidates(e, t, r) { + return [r.project.getWorkspaceByDescriptor(e).anchoredLocator]; + } + async getSatisfying(e, t, r) { + return null; + } + async resolve(e, t) { + const r = t.project.getWorkspaceByCwd( + e.reference.slice(n.protocol.length) + ); + return { + ...e, + version: r.manifest.version || '0.0.0', + languageName: 'unknown', + linkType: A.Un.SOFT, + dependencies: new Map([ + ...r.manifest.dependencies, + ...r.manifest.devDependencies, + ]), + peerDependencies: new Map([...r.manifest.peerDependencies]), + dependenciesMeta: r.manifest.dependenciesMeta, + peerDependenciesMeta: r.manifest.peerDependenciesMeta, + bin: r.manifest.bin, + }; + } + } + n.protocol = 'workspace:'; + }, + 59355: (e, t, r) => { + 'use strict'; + r.d(t, { o: () => A }); + const A = '2.4.1'; + }, + 6220: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { EndStrategy: () => A, pipevp: () => g, execvp: () => l }); + var A, + n = r(46009), + o = r(67566), + i = r.n(o); + function s(e) { + return null !== e && 'number' == typeof e.fd; + } + function a() {} + !(function (e) { + (e[(e.Never = 0)] = 'Never'), + (e[(e.ErrorCode = 1)] = 'ErrorCode'), + (e[(e.Always = 2)] = 'Always'); + })(A || (A = {})); + let c = 0; + async function g( + e, + t, + { + cwd: r, + env: o = process.env, + strict: g = !1, + stdin: l = null, + stdout: u, + stderr: p, + end: d = A.Always, + } + ) { + const C = ['pipe', 'pipe', 'pipe']; + null === l ? (C[0] = 'ignore') : s(l) && (C[0] = l), + s(u) && (C[1] = u), + s(p) && (C[2] = p), + 0 == c++ && process.on('SIGINT', a); + const f = i()(e, t, { + cwd: n.cS.fromPortablePath(r), + env: { ...o, PWD: n.cS.fromPortablePath(r) }, + stdio: C, + }); + s(l) || null === l || l.pipe(f.stdin), + s(u) || f.stdout.pipe(u, { end: !1 }), + s(p) || f.stderr.pipe(p, { end: !1 }); + const I = () => { + for (const e of new Set([u, p])) s(e) || e.end(); + }; + return new Promise((t, r) => { + f.on('error', (e) => { + 0 == --c && process.off('SIGINT', a), + (d !== A.Always && d !== A.ErrorCode) || I(), + r(e); + }), + f.on('close', (n, o) => { + 0 == --c && process.off('SIGINT', a), + (d === A.Always || (d === A.ErrorCode && n > 0)) && I(), + 0 !== n && g + ? r( + null !== n + ? new Error(`Child "${e}" exited with exit code ${n}`) + : new Error(`Child "${e}" exited with signal ${o}`) + ) + : t({ code: h(n, o) }); + }); + }); + } + async function l( + e, + t, + { cwd: r, env: A = process.env, encoding: o = 'utf8', strict: s = !1 } + ) { + const a = ['ignore', 'pipe', 'pipe'], + c = [], + g = [], + l = n.cS.fromPortablePath(r); + void 0 !== A.PWD && (A = { ...A, PWD: l }); + const u = i()(e, t, { cwd: l, env: A, stdio: a }); + return ( + u.stdout.on('data', (e) => { + c.push(e); + }), + u.stderr.on('data', (e) => { + g.push(e); + }), + await new Promise((t, r) => { + u.on('error', r), + u.on('close', (A, n) => { + const i = + 'buffer' === o + ? Buffer.concat(c) + : Buffer.concat(c).toString(o), + a = + 'buffer' === o + ? Buffer.concat(g) + : Buffer.concat(g).toString(o); + 0 !== A && s + ? r( + Object.assign( + new Error( + `Child "${e}" exited with exit code ${A}\n\n${a}` + ), + { code: h(A, n), stdout: i, stderr: a } + ) + ) + : t({ code: h(A, n), stdout: i, stderr: a }); + }); + }) + ); + } + const u = new Map([ + ['SIGINT', 2], + ['SIGQUIT', 3], + ['SIGKILL', 9], + ['SIGTERM', 15], + ]); + function h(e, t) { + const r = u.get(t); + return void 0 !== r ? 128 + r : null != e ? e : 1; + } + }, + 81111: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + getDefaultGlobalFolder: () => o, + getHomeFolder: () => i, + isFolderInside: () => s, + }); + var A = r(46009), + n = r(12087); + function o() { + if ('win32' === process.platform) { + const e = A.cS.toPortablePath( + process.env.LOCALAPPDATA || + A.cS.join((0, n.homedir)(), 'AppData', 'Local') + ); + return A.y1.resolve(e, 'Yarn/Berry'); + } + if (process.env.XDG_DATA_HOME) { + const e = A.cS.toPortablePath(process.env.XDG_DATA_HOME); + return A.y1.resolve(e, 'yarn/berry'); + } + return A.y1.resolve(i(), '.yarn/berry'); + } + function i() { + return A.cS.toPortablePath((0, n.homedir)() || '/usr/local/share'); + } + function s(e, t) { + const r = A.y1.relative(t, e); + return r && !r.startsWith('..') && !A.y1.isAbsolute(r); + } + }, + 71643: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + Type: () => A, + Style: () => n, + supportsColor: () => h, + supportsHyperlinks: () => p, + tuple: () => I, + applyStyle: () => E, + applyColor: () => B, + pretty: () => y, + prettyList: () => m, + json: () => w, + mark: () => Q, + LogLevel: () => D, + addLogFilterSupport: () => b, + }); + var A, + n, + o = r(46009), + i = r(95882), + s = r.n(i), + a = r(92659), + c = r(73632), + g = r(54143), + l = r(32485); + !(function (e) { + (e.NO_HINT = 'NO_HINT'), + (e.NULL = 'NULL'), + (e.SCOPE = 'SCOPE'), + (e.NAME = 'NAME'), + (e.RANGE = 'RANGE'), + (e.REFERENCE = 'REFERENCE'), + (e.NUMBER = 'NUMBER'), + (e.PATH = 'PATH'), + (e.URL = 'URL'), + (e.ADDED = 'ADDED'), + (e.REMOVED = 'REMOVED'), + (e.CODE = 'CODE'), + (e.DURATION = 'DURATION'), + (e.SIZE = 'SIZE'), + (e.IDENT = 'IDENT'), + (e.DESCRIPTOR = 'DESCRIPTOR'), + (e.LOCATOR = 'LOCATOR'), + (e.RESOLUTION = 'RESOLUTION'), + (e.DEPENDENT = 'DEPENDENT'), + (e.PACKAGE_EXTENSION = 'PACKAGE_EXTENSION'); + })(A || (A = {})), + (function (e) { + e[(e.BOLD = 2)] = 'BOLD'; + })(n || (n = {})); + const u = process.env.GITHUB_ACTIONS + ? { level: 2 } + : s().supportsColor + ? { level: s().supportsColor.level } + : { level: 0 }, + h = 0 !== u.level, + p = h && !process.env.GITHUB_ACTIONS, + d = new (s().Instance)(u), + C = new Map([ + [A.NO_HINT, null], + [A.NULL, ['#a853b5', 129]], + [A.SCOPE, ['#d75f00', 166]], + [A.NAME, ['#d7875f', 173]], + [A.RANGE, ['#00afaf', 37]], + [A.REFERENCE, ['#87afff', 111]], + [A.NUMBER, ['#ffd700', 220]], + [A.PATH, ['#d75fd7', 170]], + [A.URL, ['#d75fd7', 170]], + [A.ADDED, ['#5faf00', 70]], + [A.REMOVED, ['#d70000', 160]], + [A.CODE, ['#87afff', 111]], + [A.SIZE, ['#ffd700', 220]], + ]), + f = { + [A.NUMBER]: { pretty: (e, t) => '' + t, json: (e) => e }, + [A.IDENT]: { + pretty: (e, t) => g.prettyIdent(e, t), + json: (e) => g.stringifyIdent(e), + }, + [A.LOCATOR]: { + pretty: (e, t) => g.prettyLocator(e, t), + json: (e) => g.stringifyLocator(e), + }, + [A.DESCRIPTOR]: { + pretty: (e, t) => g.prettyDescriptor(e, t), + json: (e) => g.stringifyDescriptor(e), + }, + [A.RESOLUTION]: { + pretty: (e, { descriptor: t, locator: r }) => + g.prettyResolution(e, t, r), + json: ({ descriptor: e, locator: t }) => ({ + descriptor: g.stringifyDescriptor(e), + locator: null !== t ? g.stringifyLocator(t) : null, + }), + }, + [A.DEPENDENT]: { + pretty: (e, { locator: t, descriptor: r }) => + g.prettyDependent(e, t, r), + json: ({ locator: e, descriptor: t }) => ({ + locator: g.stringifyLocator(e), + descriptor: g.stringifyDescriptor(t), + }), + }, + [A.PACKAGE_EXTENSION]: { + pretty: (e, t) => { + switch (t.type) { + case l.HN.Dependency: + return `${g.prettyIdent(e, t.parentDescriptor)} ➤ ${B( + e, + 'dependencies', + A.CODE + )} ➤ ${g.prettyIdent(e, t.descriptor)}`; + case l.HN.PeerDependency: + return `${g.prettyIdent(e, t.parentDescriptor)} ➤ ${B( + e, + 'peerDependencies', + A.CODE + )} ➤ ${g.prettyIdent(e, t.descriptor)}`; + case l.HN.PeerDependencyMeta: + return `${g.prettyIdent(e, t.parentDescriptor)} ➤ ${B( + e, + 'peerDependenciesMeta', + A.CODE + )} ➤ ${g.prettyIdent(e, g.parseIdent(t.selector))} ➤ ${B( + e, + t.key, + A.CODE + )}`; + default: + throw new Error( + 'Assertion failed: Unsupported package extension type: ' + + t.type + ); + } + }, + json: (e) => { + switch (e.type) { + case l.HN.Dependency: + return `${g.stringifyIdent( + e.parentDescriptor + )} > ${g.stringifyIdent(e.descriptor)}`; + case l.HN.PeerDependency: + return `${g.stringifyIdent( + e.parentDescriptor + )} >> ${g.stringifyIdent(e.descriptor)}`; + case l.HN.PeerDependencyMeta: + return `${g.stringifyIdent(e.parentDescriptor)} >> ${ + e.selector + } / ${e.key}`; + default: + throw new Error( + 'Assertion failed: Unsupported package extension type: ' + + e.type + ); + } + }, + }, + [A.DURATION]: { + pretty: (e, t) => { + if (t > 6e4) { + const e = Math.floor(t / 1e3 / 60), + r = Math.ceil((t - 60 * e * 1e3) / 1e3); + return 0 === r ? e + 'm' : `${e}m ${r}s`; + } + { + const e = Math.floor(t / 1e3), + r = t - 1e3 * e; + return 0 === r ? e + 's' : `${e}s ${r}ms`; + } + }, + json: (e) => e, + }, + [A.SIZE]: { + pretty: (e, t) => { + const r = ['KB', 'MB', 'GB', 'TB']; + let n = r.length; + for (; n > 1 && t < 1024 ** n; ) n -= 1; + const o = 1024 ** n; + return B( + e, + `${Math.floor((100 * t) / o) / 100} ${r[n - 1]}`, + A.NUMBER + ); + }, + json: (e) => e, + }, + [A.PATH]: { + pretty: (e, t) => B(e, o.cS.fromPortablePath(t), A.PATH), + json: (e) => o.cS.fromPortablePath(e), + }, + }; + function I(e, t) { + return [t, e]; + } + function E(e, t, r) { + return e.get('enableColors') + ? (r & n.BOLD && (t = s().bold(t)), t) + : t; + } + function B(e, t, r) { + if (!e.get('enableColors')) return t; + const A = C.get(r); + if (null === A) return t; + const n = void 0 === A ? r : u.level >= 3 ? A[0] : A[1], + o = + 'number' == typeof n + ? d.ansi256(n) + : n.startsWith('#') + ? d.hex(n) + : d[n]; + if ('function' != typeof o) + throw new Error('Invalid format type ' + n); + return o(t); + } + function y(e, t, r) { + if (null === t) return B(e, 'null', A.NULL); + if (Object.prototype.hasOwnProperty.call(f, r)) { + return f[r].pretty(e, t); + } + if ('string' != typeof t) + throw new Error( + 'Assertion failed: Expected the value to be a string, got ' + + typeof t + ); + return B(e, t, r); + } + function m(e, t, r, { separator: A = ', ' } = {}) { + return [...t].map((t) => y(e, t, r)).join(A); + } + function w(e, t) { + if (null === e) return null; + if (Object.prototype.hasOwnProperty.call(f, t)) + return c.overrideType(t), f[t].json(e); + if ('string' != typeof e) + throw new Error( + 'Assertion failed: Expected the value to be a string, got ' + + typeof e + ); + return e; + } + function Q(e) { + return { + Check: B(e, '✓', 'green'), + Cross: B(e, '✘', 'red'), + Question: B(e, '?', 'cyan'), + }; + } + var D; + function b(e, { configuration: t }) { + const r = t.get('logFilters'), + A = new Map(), + n = new Map(); + for (const e of r) { + const t = e.get('level'); + if (void 0 === t) continue; + const r = e.get('code'); + void 0 !== r && A.set(r, t); + const o = e.get('text'); + void 0 !== o && n.set(o, t); + } + const o = e.reportInfo, + i = e.reportWarning, + c = e.reportError, + g = function (e, t, r, g) { + switch ( + ((e, t, r) => { + if (null === e || e === a.b.UNNAMED) return r; + if (n.size > 0) { + const e = n.get(s().reset(t)); + if (void 0 !== e) return null != e ? e : r; + } + if (A.size > 0) { + const t = A.get((0, a.i)(e)); + if (void 0 !== t) return null != t ? t : r; + } + return r; + })(t, r, g) + ) { + case D.Info: + o.call(e, t, r); + break; + case D.Warning: + i.call(e, null != t ? t : a.b.UNNAMED, r); + break; + case D.Error: + c.call(e, null != t ? t : a.b.UNNAMED, r); + } + }; + (e.reportInfo = function (...e) { + return g(this, ...e, D.Info); + }), + (e.reportWarning = function (...e) { + return g(this, ...e, D.Warning); + }), + (e.reportError = function (...e) { + return g(this, ...e, D.Error); + }); + } + !(function (e) { + (e.Error = 'error'), + (e.Warning = 'warning'), + (e.Info = 'info'), + (e.Discard = 'discard'); + })(D || (D = {})); + }, + 20624: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + makeHash: () => a, + checksumFile: () => c, + checksumPattern: () => g, + }); + var A = r(43896), + n = r(46009), + o = r(76417), + i = r(58592), + s = r.n(i); + function a(...e) { + const t = (0, o.createHash)('sha512'); + for (const r of e) t.update(r || ''); + return t.digest('hex'); + } + function c(e) { + return new Promise((t, r) => { + const n = (0, o.createHash)('sha512'), + i = A.xfs.createReadStream(e); + i.on('data', (e) => { + n.update(e); + }), + i.on('error', (e) => { + r(e); + }), + i.on('end', () => { + t(n.digest('hex')); + }); + }); + } + async function g(e, { cwd: t }) { + const r = ( + await s()(e, { + cwd: n.cS.fromPortablePath(t), + expandDirectories: !1, + onlyDirectories: !0, + unique: !0, + }) + ).map((e) => e + '/**/*'), + i = await s()([e, ...r], { + cwd: n.cS.fromPortablePath(t), + expandDirectories: !1, + onlyFiles: !1, + unique: !0, + }); + i.sort(); + const a = await Promise.all( + i.map(async (e) => { + const t = [Buffer.from(e)], + r = n.cS.toPortablePath(e), + o = await A.xfs.lstatPromise(r); + return ( + o.isSymbolicLink() + ? t.push(Buffer.from(await A.xfs.readlinkPromise(r))) + : o.isFile() && t.push(await A.xfs.readFilePromise(r)), + t.join('\0') + ); + }) + ), + c = (0, o.createHash)('sha512'); + for (const e of a) c.update(e); + return c.digest('hex'); + } + }, + 79669: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + getNetworkSettings: () => d, + Method: () => C, + request: () => f, + get: () => I, + put: () => E, + post: () => B, + del: () => y, + }); + var A = r(43896), + n = r(57211), + o = r(98605), + i = r(2401), + s = r.n(i), + a = r(98161), + c = r(78835); + const g = new Map(), + l = new Map(), + u = new o.Agent({ keepAlive: !0 }), + h = new n.Agent({ keepAlive: !0 }); + function p(e) { + const t = new c.URL(e), + r = { host: t.hostname, headers: {} }; + return t.port && (r.port = Number(t.port)), { proxy: r }; + } + function d(e, t) { + const r = [...t.configuration.get('networkSettings')].sort( + ([e], [t]) => t.length - e.length + ), + A = { + enableNetwork: void 0, + caFilePath: void 0, + httpProxy: void 0, + httpsProxy: void 0, + }, + n = Object.keys(A), + o = new c.URL(e); + for (const [e, t] of r) + if (s().isMatch(o.hostname, e)) + for (const e of n) { + const r = t.get(e); + null !== r && void 0 === A[e] && (A[e] = r); + } + for (const e of n) void 0 === A[e] && (A[e] = t.configuration.get(e)); + return A; + } + var C; + async function f( + e, + t, + { + configuration: n, + headers: o, + json: i, + jsonRequest: g = i, + jsonResponse: f = i, + method: I = C.GET, + } + ) { + const E = d(e, { configuration: n }); + if (!1 === E.enableNetwork) + throw new Error( + `Request to '${e}' has been blocked because of your configuration settings` + ); + const B = new c.URL(e); + if ( + 'http:' === B.protocol && + !s().isMatch(B.hostname, n.get('unsafeHttpWhitelist')) + ) + throw new Error( + `Unsafe http requests must be explicitly whitelisted in your configuration (${B.hostname})` + ); + const y = { + agent: { + http: E.httpProxy ? a.httpOverHttp(p(E.httpProxy)) : u, + https: E.httpsProxy ? a.httpsOverHttp(p(E.httpsProxy)) : h, + }, + headers: o, + method: I, + }; + (y.responseType = f ? 'json' : 'buffer'), + null !== t && + (Buffer.isBuffer(t) || (!g && 'string' == typeof t) + ? (y.body = t) + : (y.json = t)); + const m = n.get('httpTimeout'), + w = n.get('httpRetry'), + Q = n.get('enableStrictSsl'), + D = E.caFilePath, + { default: b } = await Promise.resolve().then( + r.t.bind(r, 48722, 7) + ), + v = D + ? await (async function (e) { + let t = l.get(e); + return ( + t || + ((t = A.xfs + .readFilePromise(e) + .then((t) => (l.set(e, t), t))), + l.set(e, t)), + t + ); + })(D) + : void 0, + S = b.extend({ + timeout: { socket: m }, + retry: w, + https: { rejectUnauthorized: Q, certificateAuthority: v }, + ...y, + }); + return n.getLimit('networkConcurrency')(() => S(e)); + } + async function I( + e, + { configuration: t, json: r, jsonResponse: A = r, ...n } + ) { + let o = g.get(e); + return ( + o || + ((o = f(e, null, { configuration: t, ...n }).then( + (t) => (g.set(e, t.body), t.body) + )), + g.set(e, o)), + !1 === Buffer.isBuffer(o) && (o = await o), + A ? JSON.parse(o.toString()) : o + ); + } + async function E(e, t, r) { + return (await f(e, t, { ...r, method: C.PUT })).body; + } + async function B(e, t, r) { + return (await f(e, t, { ...r, method: C.POST })).body; + } + async function y(e, t) { + return (await f(e, null, { ...t, method: C.DELETE })).body; + } + !(function (e) { + (e.GET = 'GET'), + (e.PUT = 'PUT'), + (e.POST = 'POST'), + (e.DELETE = 'DELETE'); + })(C || (C = {})); + }, + 53836: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + Cache: () => p.C, + DEFAULT_RC_FILENAME: () => d.tr, + DEFAULT_LOCK_FILENAME: () => d.nh, + Configuration: () => d.VK, + FormatType: () => d.a5, + ProjectLookup: () => d.EW, + SettingsType: () => d.a2, + BuildType: () => C.k, + LightReport: () => f.h, + Manifest: () => I.G, + MessageName: () => E.b, + Project: () => B.I, + TAG_REGEXP: () => y.c, + ReportError: () => m.lk, + Report: () => m.yG, + StreamReport: () => w.Pk, + TelemetryManager: () => Q.E, + ThrowReport: () => D.$, + VirtualFetcher: () => b.N, + WorkspaceResolver: () => v.d, + Workspace: () => S.j, + YarnVersion: () => k.o, + LinkType: () => N.Un, + PackageExtensionType: () => N.HN, + PackageExtensionStatus: () => N._u, + hashUtils: () => i, + httpUtils: () => s, + execUtils: () => A, + folderUtils: () => n, + formatUtils: () => o, + miscUtils: () => a, + scriptUtils: () => c, + semverUtils: () => g, + structUtils: () => l, + tgzUtils: () => u, + treeUtils: () => h, + }); + var A = r(6220), + n = r(81111), + o = r(71643), + i = r(20624), + s = r(79669), + a = r(73632), + c = r(63088), + g = r(36545), + l = r(54143), + u = r(72785), + h = r(85875), + p = r(28148), + d = r(39922), + C = r(92409), + f = r(62152), + I = r(46611), + E = r(92659), + B = r(85824), + y = r(52779), + m = r(35691), + w = r(15815), + Q = r(81832), + D = r(33720), + b = r(60895), + v = r(94538), + S = r(17722), + k = r(59355), + N = r(32485); + }, + 73632: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + escapeRegExp: () => a, + overrideType: () => c, + assertNever: () => g, + validateEnum: () => l, + mapAndFilter: () => u, + mapAndFind: () => p, + isIndexableObject: () => C, + convertMapsToIndexableObjects: () => f, + getFactoryWithDefault: () => I, + getArrayWithDefault: () => E, + getSetWithDefault: () => B, + getMapWithDefault: () => y, + releaseAfterUseAsync: () => m, + prettifyAsyncErrors: () => w, + prettifySyncErrors: () => Q, + bufferStream: () => D, + BufferStream: () => b, + DefaultStream: () => v, + dynamicRequire: () => S, + dynamicRequireNoCache: () => k, + sortMap: () => N, + buildIgnorePattern: () => F, + replaceEnvVariables: () => K, + parseBoolean: () => M, + parseOptionalBoolean: () => R, + tryParseOptionalBoolean: () => x, + }); + var A = r(46009), + n = r(40822), + o = r(2401), + i = r.n(o), + s = r(92413); + function a(e) { + return e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); + } + function c(e) {} + function g(e) { + throw new Error(`Assertion failed: Unexpected object '${e}'`); + } + function l(e, t) { + if (!Object.values(e).includes(t)) + throw new Error('Assertion failed: Invalid value for enumeration'); + return t; + } + function u(e, t) { + const r = []; + for (const A of e) { + const e = t(A); + e !== h && r.push(e); + } + return r; + } + e = r.hmd(e); + const h = Symbol(); + function p(e, t) { + for (const r of e) { + const e = t(r); + if (e !== d) return e; + } + } + u.skip = h; + const d = Symbol(); + function C(e) { + return 'object' == typeof e && null !== e; + } + function f(e) { + if ((e instanceof Map && (e = Object.fromEntries(e)), C(e))) + for (const t of Object.keys(e)) { + const r = e[t]; + C(r) && (e[t] = f(r)); + } + return e; + } + function I(e, t, r) { + let A = e.get(t); + return void 0 === A && e.set(t, (A = r())), A; + } + function E(e, t) { + let r = e.get(t); + return void 0 === r && e.set(t, (r = [])), r; + } + function B(e, t) { + let r = e.get(t); + return void 0 === r && e.set(t, (r = new Set())), r; + } + function y(e, t) { + let r = e.get(t); + return void 0 === r && e.set(t, (r = new Map())), r; + } + async function m(e, t) { + if (null == t) return await e(); + try { + return await e(); + } finally { + await t(); + } + } + async function w(e, t) { + try { + return await e(); + } catch (e) { + throw ((e.message = t(e.message)), e); + } + } + function Q(e, t) { + try { + return e(); + } catch (e) { + throw ((e.message = t(e.message)), e); + } + } + async function D(e) { + return await new Promise((t, r) => { + const A = []; + e.on('error', (e) => { + r(e); + }), + e.on('data', (e) => { + A.push(e); + }), + e.on('end', () => { + t(Buffer.concat(A)); + }); + }); + } + p.skip = d; + class b extends s.Transform { + constructor() { + super(...arguments), (this.chunks = []); + } + _transform(e, t, r) { + if ('buffer' !== t || !Buffer.isBuffer(e)) + throw new Error( + 'Assertion failed: BufferStream only accept buffers' + ); + this.chunks.push(e), r(null, null); + } + _flush(e) { + e(null, Buffer.concat(this.chunks)); + } + } + class v extends s.Transform { + constructor(e = Buffer.alloc(0)) { + super(), (this.active = !0), (this.ifEmpty = e); + } + _transform(e, t, r) { + if ('buffer' !== t || !Buffer.isBuffer(e)) + throw new Error( + 'Assertion failed: DefaultStream only accept buffers' + ); + (this.active = !1), r(null, e); + } + _flush(e) { + this.active && this.ifEmpty.length > 0 && e(null, this.ifEmpty); + } + } + function S(e) { + return 'undefined' != typeof require ? require(e) : r(32178)(e); + } + function k(t) { + const n = A.cS.fromPortablePath(t), + o = r.c[n]; + let i; + delete r.c[n]; + try { + i = S(n); + const t = r.c[n], + A = e.children.indexOf(t); + -1 !== A && e.children.splice(A, 1); + } finally { + r.c[n] = o; + } + return i; + } + function N(e, t) { + const r = Array.from(e); + Array.isArray(t) || (t = [t]); + const A = []; + for (const e of t) A.push(r.map((t) => e(t))); + const n = r.map((e, t) => t); + return ( + n.sort((e, t) => { + for (const r of A) { + const A = r[e] < r[t] ? -1 : r[e] > r[t] ? 1 : 0; + if (0 !== A) return A; + } + return 0; + }), + n.map((e) => r[e]) + ); + } + function F(e) { + return 0 === e.length + ? null + : e + .map((e) => `(${i().makeRe(e, { windows: !1 }).source})`) + .join('|'); + } + function K(e, { env: t }) { + return e.replace( + /\${(?[\d\w_]+)(?:)?(?:-(?[^}]*))?}/g, + (...e) => { + const { variableName: r, colon: A, fallback: o } = e[ + e.length - 1 + ], + i = Object.prototype.hasOwnProperty.call(t, r), + s = t[r]; + if (s) return s; + if (i && !A) return s; + if (null != o) return o; + throw new n.UsageError(`Environment variable not found (${r})`); + } + ); + } + function M(e) { + switch (e) { + case 'true': + case '1': + case 1: + case !0: + return !0; + case 'false': + case '0': + case 0: + case !1: + return !1; + default: + throw new Error(`Couldn't parse "${e}" as a boolean`); + } + } + function R(e) { + return void 0 === e ? e : M(e); + } + function x(e) { + try { + return R(e); + } catch (e) { + return null; + } + } + }, + 63088: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + makeScriptEnv: () => b, + prepareExternalProject: () => S, + hasPackageScript: () => k, + executePackageScript: () => N, + executePackageShellcode: () => F, + executeWorkspaceScript: () => M, + hasWorkspaceScript: () => R, + executeWorkspaceLifecycleScript: () => x, + maybeExecuteWorkspaceLifecycleScript: () => L, + getPackageAccessibleBinaries: () => P, + getWorkspaceAccessibleBinaries: () => O, + executePackageAccessibleBinary: () => U, + executeWorkspaceAccessibleBinary: () => T, + }); + var A, + n = r(46009), + o = r(53660), + i = r(75448), + s = r(43896), + a = r(65281), + c = r(76756), + g = r(50730), + l = r(61814), + u = r.n(l), + h = r(61578), + p = r.n(h), + d = r(92413), + C = r(46611), + f = r(92659), + I = r(35691), + E = r(15815), + B = r(59355), + y = r(6220), + m = r(71643), + w = r(73632), + Q = r(54143); + async function D(e, t, r, A = []) { + 'win32' === process.platform && + (await Promise.all([ + s.xfs.writeFilePromise( + n.y1.format({ dir: e, name: t, ext: '.exe' }), + (0, g.O9)() + ), + s.xfs.writeFilePromise( + n.y1.format({ dir: e, name: t, ext: '.exe.info' }), + [r, ...A].join('\n') + ), + s.xfs.writeFilePromise( + n.y1.format({ dir: e, name: t, ext: '.cmd' }), + `@"${r}" ${A.map((e) => `"${e.replace('"', '""')}"`).join( + ' ' + )} %*\n` + ), + ])), + await s.xfs.writeFilePromise( + n.y1.join(e, t), + `#!/bin/sh\nexec "${r}" ${A.map( + (e) => `'${e.replace(/'/g, "'\"'\"'")}'` + ).join(' ')} "$@"\n` + ), + await s.xfs.chmodPromise(n.y1.join(e, t), 493); + } + async function b({ project: e, binFolder: t, lifecycleScript: r }) { + const A = {}; + for (const [e, t] of Object.entries(process.env)) + void 0 !== t && (A['path' !== e.toLowerCase() ? e : 'PATH'] = t); + const o = n.cS.fromPortablePath(t); + (A.BERRY_BIN_FOLDER = n.cS.fromPortablePath(o)), + await D(t, 'node', process.execPath), + null !== B.o && + (await D(t, 'run', process.execPath, [process.argv[1], 'run']), + await D(t, 'yarn', process.execPath, [process.argv[1]]), + await D(t, 'yarnpkg', process.execPath, [process.argv[1]]), + await D(t, 'node-gyp', process.execPath, [ + process.argv[1], + 'run', + '--top-level', + 'node-gyp', + ])), + e && + (A.INIT_CWD = n.cS.fromPortablePath(e.configuration.startingCwd)), + (A.PATH = A.PATH ? `${o}${n.cS.delimiter}${A.PATH}` : '' + o), + (A.npm_execpath = `${o}${n.cS.sep}yarn`), + (A.npm_node_execpath = `${o}${n.cS.sep}node`); + const i = + null !== B.o + ? 'yarn/' + B.o + : `yarn/${w.dynamicRequire('@yarnpkg/core').version}-core`; + return ( + (A.npm_config_user_agent = `${i} npm/? node/${process.versions.node} ${process.platform} ${process.arch}`), + r && (A.npm_lifecycle_event = r), + e && + (await e.configuration.triggerHook( + (e) => e.setupScriptEnvironment, + e, + A, + async (e, r, A) => await D(t, (0, n.Zu)(e), r, A) + )), + A + ); + } + !(function (e) { + (e.Yarn1 = 'Yarn Classic'), + (e.Yarn2 = 'Yarn'), + (e.Npm = 'npm'), + (e.Pnpm = 'pnpm'); + })(A || (A = {})); + const v = p()(2); + async function S( + e, + t, + { configuration: r, report: o, workspace: i = null } + ) { + await v(async () => { + await s.xfs.mktempPromise(async (a) => { + const c = n.y1.join(a, 'pack.log'), + { stdout: g, stderr: l } = r.getSubprocessStreams(c, { + prefix: e, + report: o, + }), + u = await (async function (e) { + let t = null; + try { + t = await s.xfs.readFilePromise( + n.y1.join(e, n.QS.lockfile), + 'utf8' + ); + } catch (e) {} + return null !== t + ? t.match(/^__metadata:$/m) + ? A.Yarn2 + : A.Yarn1 + : s.xfs.existsSync(n.y1.join(e, 'package-lock.json')) + ? A.Npm + : s.xfs.existsSync(n.y1.join(e, 'pnpm-lock.yaml')) + ? A.Pnpm + : null; + })(e); + let h; + null !== u + ? (g.write(`Installing the project using ${u}\n\n`), (h = u)) + : (g.write( + 'No package manager detected; defaulting to Yarn\n\n' + ), + (h = A.Yarn2)), + await s.xfs.mktempPromise(async (r) => { + const o = await b({ binFolder: r }), + u = new Map([ + [ + A.Yarn1, + async () => { + const r = null !== i ? ['workspace', i] : [], + A = await y.pipevp( + 'yarn', + ['set', 'version', 'classic', '--only-if-needed'], + { + cwd: e, + env: o, + stdin: null, + stdout: g, + stderr: l, + end: y.EndStrategy.ErrorCode, + } + ); + if (0 !== A.code) return A.code; + await s.xfs.appendFilePromise( + n.y1.join(e, '.npmignore'), + '/.yarn\n' + ), + g.write('\n'); + const a = await y.pipevp('yarn', ['install'], { + cwd: e, + env: o, + stdin: null, + stdout: g, + stderr: l, + end: y.EndStrategy.ErrorCode, + }); + if (0 !== a.code) return a.code; + g.write('\n'); + const c = await y.pipevp( + 'yarn', + [ + ...r, + 'pack', + '--filename', + n.cS.fromPortablePath(t), + ], + { + cwd: e, + env: o, + stdin: null, + stdout: g, + stderr: l, + } + ); + return 0 !== c.code ? c.code : 0; + }, + ], + [ + A.Yarn2, + async () => { + const r = null !== i ? ['workspace', i] : []; + o.YARN_ENABLE_INLINE_BUILDS = '1'; + const A = n.y1.join(e, n.QS.lockfile); + (await s.xfs.existsPromise(A)) || + (await s.xfs.writeFilePromise(A, '')); + const a = await y.pipevp( + 'yarn', + [ + ...r, + 'pack', + '--install-if-needed', + '--filename', + n.cS.fromPortablePath(t), + ], + { + cwd: e, + env: o, + stdin: null, + stdout: g, + stderr: l, + } + ); + return 0 !== a.code ? a.code : 0; + }, + ], + [ + A.Npm, + async () => { + if (null !== i) + throw new Error( + "Workspaces aren't supported by npm, which has been detected as the primary package manager for " + + e + ); + delete o.npm_config_user_agent; + const r = await y.pipevp('npm', ['install'], { + cwd: e, + env: o, + stdin: null, + stdout: g, + stderr: l, + end: y.EndStrategy.ErrorCode, + }); + if (0 !== r.code) return r.code; + const A = new d.PassThrough(), + a = w.bufferStream(A); + A.pipe(g); + const c = await y.pipevp( + 'npm', + ['pack', '--silent'], + { + cwd: e, + env: o, + stdin: null, + stdout: A, + stderr: l, + } + ); + if (0 !== c.code) return c.code; + const u = (await a).toString().trim(), + h = n.y1.resolve(e, n.cS.toPortablePath(u)); + return await s.xfs.renamePromise(h, t), 0; + }, + ], + ]).get(h); + if (void 0 === u) + throw new Error('Assertion failed: Unsupported workflow'); + const p = await u(); + if (0 !== p && void 0 !== p) + throw ( + (s.xfs.detachTemp(a), + new I.lk( + f.b.PACKAGE_PREPARATION_FAILED, + `Packing the package failed (exit code ${p}, logs can be found here: ${c})` + )) + ); + }); + }); + }); + } + async function k(e, t, { project: r }) { + const A = r.storedPackages.get(e.locatorHash); + if (!A) + throw new Error( + `Package for ${Q.prettyLocator( + r.configuration, + e + )} not found in the project` + ); + return await o.A.openPromise( + async (e) => { + const o = r.configuration, + s = r.configuration.getLinkers(), + a = { + project: r, + report: new E.Pk({ + stdout: new d.PassThrough(), + configuration: o, + }), + }, + c = s.find((e) => e.supportsPackage(A, a)); + if (!c) + throw new Error( + `The package ${Q.prettyLocator( + r.configuration, + A + )} isn't supported by any of the available linkers` + ); + const g = await c.findPackageLocation(A, a), + l = new i.M(g, { baseFs: e }); + return (await C.G.find(n.LZ.dot, { baseFs: l })).scripts.has(t); + }, + { libzip: await (0, a.getLibzipPromise)() } + ); + } + async function N( + e, + t, + r, + { cwd: A, project: n, stdin: o, stdout: i, stderr: a } + ) { + return await s.xfs.mktempPromise(async (s) => { + const { manifest: g, env: l, cwd: u } = await K(e, { + project: n, + binFolder: s, + cwd: A, + lifecycleScript: t, + }), + h = g.scripts.get(t); + if (void 0 === h) return 1; + const p = await n.configuration.reduceHook( + (e) => e.wrapScriptExecution, + async () => + await (0, c.execute)(h, r, { + cwd: u, + env: l, + stdin: o, + stdout: i, + stderr: a, + }), + n, + e, + t, + { + script: h, + args: r, + cwd: u, + env: l, + stdin: o, + stdout: i, + stderr: a, + } + ); + return await p(); + }); + } + async function F( + e, + t, + r, + { cwd: A, project: n, stdin: o, stdout: i, stderr: a } + ) { + return await s.xfs.mktempPromise(async (s) => { + const { env: g, cwd: l } = await K(e, { + project: n, + binFolder: s, + cwd: A, + }); + return await (0, c.execute)(t, r, { + cwd: l, + env: g, + stdin: o, + stdout: i, + stderr: a, + }); + }); + } + async function K( + e, + { project: t, binFolder: r, cwd: A, lifecycleScript: s } + ) { + const c = t.storedPackages.get(e.locatorHash); + if (!c) + throw new Error( + `Package for ${Q.prettyLocator( + t.configuration, + e + )} not found in the project` + ); + return await o.A.openPromise( + async (o) => { + const a = t.configuration, + g = t.configuration.getLinkers(), + l = { + project: t, + report: new E.Pk({ + stdout: new d.PassThrough(), + configuration: a, + }), + }, + u = g.find((e) => e.supportsPackage(c, l)); + if (!u) + throw new Error( + `The package ${Q.prettyLocator( + t.configuration, + c + )} isn't supported by any of the available linkers` + ); + const h = await b({ + project: t, + binFolder: r, + lifecycleScript: s, + }); + await Promise.all( + Array.from(await P(e, { project: t }), ([e, [, t]]) => + D(r, (0, n.Zu)(e), process.execPath, [t]) + ) + ); + const p = await u.findPackageLocation(c, l), + f = new i.M(p, { baseFs: o }), + I = await C.G.find(n.LZ.dot, { baseFs: f }); + return ( + void 0 === A && (A = p), + { manifest: I, binFolder: r, env: h, cwd: A } + ); + }, + { libzip: await (0, a.getLibzipPromise)() } + ); + } + async function M(e, t, r, { cwd: A, stdin: n, stdout: o, stderr: i }) { + return await N(e.anchoredLocator, t, r, { + cwd: A, + project: e.project, + stdin: n, + stdout: o, + stderr: i, + }); + } + function R(e, t) { + return e.manifest.scripts.has(t); + } + async function x(e, t, { cwd: r, report: A }) { + const { configuration: o } = e.project; + await s.xfs.mktempPromise(async (i) => { + const a = n.y1.join(i, t + '.log'), + c = `# This file contains the result of Yarn calling the "${t}" lifecycle script inside a workspace ("${e.cwd}")\n`, + { stdout: g, stderr: l } = o.getSubprocessStreams(a, { + report: A, + prefix: Q.prettyLocator(o, e.anchoredLocator), + header: c, + }); + A.reportInfo( + f.b.LIFECYCLE_SCRIPT, + `Calling the "${t}" lifecycle script` + ); + const h = await M(e, t, [], { + cwd: r, + stdin: null, + stdout: g, + stderr: l, + }); + if ((g.end(), l.end(), 0 !== h)) + throw ( + (s.xfs.detachTemp(i), + new I.lk( + f.b.LIFECYCLE_SCRIPT, + `${u()(t)} script failed (exit code ${m.pretty( + o, + h, + m.Type.NUMBER + )}, logs can be found here: ${m.pretty( + o, + a, + m.Type.PATH + )}); run ${m.pretty( + o, + 'yarn ' + t, + m.Type.CODE + )} to investigate` + )) + ); + }); + } + async function L(e, t, r) { + R(e, t) && (await x(e, t, r)); + } + async function P(e, { project: t }) { + const r = t.configuration, + A = new Map(), + o = t.storedPackages.get(e.locatorHash); + if (!o) + throw new Error( + `Package for ${Q.prettyLocator(r, e)} not found in the project` + ); + const i = new d.Writable(), + s = r.getLinkers(), + a = { + project: t, + report: new E.Pk({ configuration: r, stdout: i }), + }, + c = new Set([e.locatorHash]); + for (const e of o.dependencies.values()) { + const A = t.storedResolutions.get(e.descriptorHash); + if (!A) + throw new Error( + `Assertion failed: The resolution (${Q.prettyDescriptor( + r, + e + )}) should have been registered` + ); + c.add(A); + } + for (const e of c) { + const r = t.storedPackages.get(e); + if (!r) + throw new Error( + `Assertion failed: The package (${e}) should have been registered` + ); + if (0 === r.bin.size) continue; + const o = s.find((e) => e.supportsPackage(r, a)); + if (!o) continue; + let i = null; + try { + i = await o.findPackageLocation(r, a); + } catch (e) { + if ('LOCATOR_NOT_INSTALLED' === e.code) continue; + throw e; + } + for (const [e, t] of r.bin) + A.set(e, [r, n.cS.fromPortablePath(n.y1.resolve(i, t))]); + } + return A; + } + async function O(e) { + return await P(e.anchoredLocator, { project: e.project }); + } + async function U( + e, + t, + r, + { + cwd: A, + project: o, + stdin: i, + stdout: a, + stderr: c, + nodeArgs: g = [], + } + ) { + const l = await P(e, { project: o }), + u = l.get(t); + if (!u) + throw new Error( + `Binary not found (${t}) for ${Q.prettyLocator( + o.configuration, + e + )}` + ); + return await s.xfs.mktempPromise(async (e) => { + const [, t] = u, + h = await b({ project: o, binFolder: e }); + let p; + await Promise.all( + Array.from(l, ([e, [, t]]) => + D(h.BERRY_BIN_FOLDER, (0, n.Zu)(e), process.execPath, [t]) + ) + ); + try { + p = await y.pipevp(process.execPath, [...g, t, ...r], { + cwd: A, + env: h, + stdin: i, + stdout: a, + stderr: c, + }); + } finally { + await s.xfs.removePromise(h.BERRY_BIN_FOLDER); + } + return p.code; + }); + } + async function T(e, t, r, { cwd: A, stdin: n, stdout: o, stderr: i }) { + return await U(e.anchoredLocator, t, r, { + project: e.project, + cwd: A, + stdin: n, + stdout: o, + stderr: i, + }); + } + }, + 36545: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { satisfiesWithPrereleases: () => o, validRange: () => s }); + var A = r(53887), + n = r.n(A); + function o(e, t, r = !1) { + let A, o; + try { + A = new (n().Range)(t, { includePrerelease: !0, loose: r }); + } catch (e) { + return !1; + } + if (!e) return !1; + try { + (o = new (n().SemVer)(e, A)), o.prerelease && (o.prerelease = []); + } catch (e) { + return !1; + } + return A.set.some((e) => { + for (const t of e) + t.semver.prerelease && (t.semver.prerelease = []); + return e.every((e) => e.test(o)); + }); + } + const i = new Map(); + function s(e) { + if (-1 !== e.indexOf(':')) return null; + let t = i.get(e); + if (void 0 !== t) return t; + try { + t = new (n().Range)(e); + } catch (e) { + t = null; + } + return i.set(e, t), t; + } + }, + 54143: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + makeIdent: () => u, + makeDescriptor: () => h, + makeLocator: () => p, + convertToIdent: () => d, + convertDescriptorToLocator: () => C, + convertLocatorToDescriptor: () => f, + convertPackageToLocator: () => I, + renamePackage: () => E, + copyPackage: () => B, + virtualizeDescriptor: () => y, + virtualizePackage: () => m, + isVirtualDescriptor: () => w, + isVirtualLocator: () => Q, + devirtualizeDescriptor: () => D, + devirtualizeLocator: () => b, + bindDescriptor: () => v, + bindLocator: () => S, + areIdentsEqual: () => k, + areDescriptorsEqual: () => N, + areLocatorsEqual: () => F, + areVirtualPackagesEquivalent: () => K, + parseIdent: () => M, + tryParseIdent: () => R, + parseDescriptor: () => x, + tryParseDescriptor: () => L, + parseLocator: () => P, + tryParseLocator: () => O, + parseRange: () => U, + parseFileStyleRange: () => T, + makeRange: () => Y, + convertToManifestRange: () => G, + requirableIdent: () => H, + stringifyIdent: () => J, + stringifyDescriptor: () => q, + stringifyLocator: () => z, + slugifyIdent: () => W, + slugifyLocator: () => V, + prettyIdent: () => X, + prettyRange: () => Z, + prettyDescriptor: () => $, + prettyReference: () => ee, + prettyLocator: () => te, + prettyLocatorNoColors: () => re, + sortDescriptors: () => Ae, + prettyWorkspace: () => ne, + prettyResolution: () => oe, + prettyDependent: () => ie, + getIdentVendorPath: () => se, + }); + var A = r(46009), + n = r(71191), + o = r.n(n), + i = r(53887), + s = r.n(i), + a = r(71643), + c = r(20624), + g = r(73632), + l = r(54143); + function u(e, t) { + if (null == e ? void 0 : e.startsWith('@')) + throw new Error("Invalid scope: don't prefix it with '@'"); + return { identHash: c.makeHash(e, t), scope: e, name: t }; + } + function h(e, t) { + return { + identHash: e.identHash, + scope: e.scope, + name: e.name, + descriptorHash: c.makeHash(e.identHash, t), + range: t, + }; + } + function p(e, t) { + return { + identHash: e.identHash, + scope: e.scope, + name: e.name, + locatorHash: c.makeHash(e.identHash, t), + reference: t, + }; + } + function d(e) { + return { identHash: e.identHash, scope: e.scope, name: e.name }; + } + function C(e) { + return { + identHash: e.identHash, + scope: e.scope, + name: e.name, + locatorHash: e.descriptorHash, + reference: e.range, + }; + } + function f(e) { + return { + identHash: e.identHash, + scope: e.scope, + name: e.name, + descriptorHash: e.locatorHash, + range: e.reference, + }; + } + function I(e) { + return { + identHash: e.identHash, + scope: e.scope, + name: e.name, + locatorHash: e.locatorHash, + reference: e.reference, + }; + } + function E(e, t) { + return { + identHash: t.identHash, + scope: t.scope, + name: t.name, + locatorHash: t.locatorHash, + reference: t.reference, + version: e.version, + languageName: e.languageName, + linkType: e.linkType, + dependencies: new Map(e.dependencies), + peerDependencies: new Map(e.peerDependencies), + dependenciesMeta: new Map(e.dependenciesMeta), + peerDependenciesMeta: new Map(e.peerDependenciesMeta), + bin: new Map(e.bin), + }; + } + function B(e) { + return E(e, e); + } + function y(e, t) { + if (t.includes('#')) throw new Error('Invalid entropy'); + return h(e, `virtual:${t}#${e.range}`); + } + function m(e, t) { + if (t.includes('#')) throw new Error('Invalid entropy'); + return E(e, p(e, `virtual:${t}#${e.reference}`)); + } + function w(e) { + return e.range.startsWith('virtual:'); + } + function Q(e) { + return e.reference.startsWith('virtual:'); + } + function D(e) { + if (!w(e)) throw new Error('Not a virtual descriptor'); + return h(e, e.range.replace(/^[^#]*#/, '')); + } + function b(e) { + if (!Q(e)) throw new Error('Not a virtual descriptor'); + return p(e, e.reference.replace(/^[^#]*#/, '')); + } + function v(e, t) { + return e.range.includes('::') + ? e + : h(e, `${e.range}::${o().stringify(t)}`); + } + function S(e, t) { + return e.reference.includes('::') + ? e + : p(e, `${e.reference}::${o().stringify(t)}`); + } + function k(e, t) { + return e.identHash === t.identHash; + } + function N(e, t) { + return e.descriptorHash === t.descriptorHash; + } + function F(e, t) { + return e.locatorHash === t.locatorHash; + } + function K(e, t) { + if (!Q(e)) throw new Error('Invalid package type'); + if (!Q(t)) throw new Error('Invalid package type'); + if (!k(e, t)) return !1; + if (e.dependencies.size !== t.dependencies.size) return !1; + for (const r of e.dependencies.values()) { + const e = t.dependencies.get(r.identHash); + if (!e) return !1; + if (!N(r, e)) return !1; + } + return !0; + } + function M(e) { + const t = R(e); + if (!t) throw new Error(`Invalid ident (${e})`); + return t; + } + function R(e) { + const t = e.match(/^(?:@([^/]+?)\/)?([^/]+)$/); + if (!t) return null; + const [, r, A] = t; + return u(void 0 !== r ? r : null, A); + } + function x(e, t = !1) { + const r = L(e, t); + if (!r) throw new Error(`Invalid descriptor (${e})`); + return r; + } + function L(e, t = !1) { + const r = t + ? e.match(/^(?:@([^/]+?)\/)?([^/]+?)(?:@(.+))$/) + : e.match(/^(?:@([^/]+?)\/)?([^/]+?)(?:@(.+))?$/); + if (!r) return null; + const [, A, n, o] = r; + if ('unknown' === o) throw new Error(`Invalid range (${e})`); + const i = void 0 !== o ? o : 'unknown'; + return h(u(void 0 !== A ? A : null, n), i); + } + function P(e, t = !1) { + const r = O(e, t); + if (!r) throw new Error(`Invalid locator (${e})`); + return r; + } + function O(e, t = !1) { + const r = t + ? e.match(/^(?:@([^/]+?)\/)?([^/]+?)(?:@(.+))$/) + : e.match(/^(?:@([^/]+?)\/)?([^/]+?)(?:@(.+))?$/); + if (!r) return null; + const [, A, n, o] = r; + if ('unknown' === o) throw new Error(`Invalid reference (${e})`); + const i = void 0 !== o ? o : 'unknown'; + return p(u(void 0 !== A ? A : null, n), i); + } + function U(e, t) { + const r = e.match( + /^([^#:]*:)?((?:(?!::)[^#])*)(?:#((?:(?!::).)*))?(?:::(.*))?$/ + ); + if (null === r) throw new Error(`Invalid range (${e})`); + const A = void 0 !== r[1] ? r[1] : null; + if ( + 'string' == typeof (null == t ? void 0 : t.requireProtocol) && + A !== t.requireProtocol + ) + throw new Error(`Invalid protocol (${A})`); + if ((null == t ? void 0 : t.requireProtocol) && null === A) + throw new Error(`Missing protocol (${A})`); + const n = void 0 !== r[3] ? decodeURIComponent(r[2]) : null; + if ((null == t ? void 0 : t.requireSource) && null === n) + throw new Error(`Missing source (${e})`); + const i = + void 0 !== r[3] + ? decodeURIComponent(r[3]) + : decodeURIComponent(r[2]); + return { + protocol: A, + source: n, + selector: (null == t ? void 0 : t.parseSelector) ? o().parse(i) : i, + params: void 0 !== r[4] ? o().parse(r[4]) : null, + }; + } + function T(e, { protocol: t }) { + const { selector: r, params: A } = U(e, { + requireProtocol: t, + requireBindings: !0, + }); + if ('string' != typeof A.locator) + throw new Error('Assertion failed: Invalid bindings for ' + e); + return { parentLocator: P(A.locator, !0), path: r }; + } + function j(e) { + return (e = (e = (e = e.replace(/%/g, '%25')).replace( + /:/g, + '%3A' + )).replace(/#/g, '%23')); + } + function Y({ protocol: e, source: t, selector: r, params: A }) { + let n = ''; + return ( + null !== e && (n += '' + e), + null !== t && (n += j(t) + '#'), + (n += j(r)), + (function (e) { + return null !== e && Object.entries(e).length > 0; + })(A) && (n += '::' + o().stringify(A)), + n + ); + } + function G(e) { + const { params: t, protocol: r, source: A, selector: n } = U(e); + for (const e in t) e.startsWith('__') && delete t[e]; + return Y({ protocol: r, source: A, params: t, selector: n }); + } + function H(e) { + return e.scope ? `@${e.scope}/${e.name}` : '' + e.name; + } + function J(e) { + return e.scope ? `@${e.scope}/${e.name}` : '' + e.name; + } + function q(e) { + return e.scope + ? `@${e.scope}/${e.name}@${e.range}` + : `${e.name}@${e.range}`; + } + function z(e) { + return e.scope + ? `@${e.scope}/${e.name}@${e.reference}` + : `${e.name}@${e.reference}`; + } + function W(e) { + return null !== e.scope ? `@${e.scope}-${e.name}` : e.name; + } + function V(e) { + const { protocol: t, selector: r } = U(e.reference), + n = null !== t ? t.replace(/:$/, '') : 'exotic', + o = s().valid(r), + i = null !== o ? `${n}-${o}` : '' + n, + a = (e.scope, `${W(e)}-${i}-${e.locatorHash.slice(0, 10)}`); + return (0, A.Zu)(a); + } + function X(e, t) { + return t.scope + ? `${a.pretty(e, `@${t.scope}/`, a.Type.SCOPE)}${a.pretty( + e, + t.name, + a.Type.NAME + )}` + : '' + a.pretty(e, t.name, a.Type.NAME); + } + function _(e) { + if (e.startsWith('virtual:')) { + return `${_(e.substr(e.indexOf('#') + 1))} [${e.substr( + 'virtual:'.length, + 5 + )}]`; + } + return e.replace(/\?.*/, '?[...]'); + } + function Z(e, t) { + return '' + a.pretty(e, _(t), a.Type.RANGE); + } + function $(e, t) { + return `${X(e, t)}${a.pretty(e, '@', a.Type.RANGE)}${Z(e, t.range)}`; + } + function ee(e, t) { + return '' + a.pretty(e, _(t), a.Type.REFERENCE); + } + function te(e, t) { + return `${X(e, t)}${a.pretty(e, '@', a.Type.REFERENCE)}${ee( + e, + t.reference + )}`; + } + function re(e) { + return `${J(e)}@${_(e.reference)}`; + } + function Ae(e) { + return g.sortMap(e, [(e) => J(e), (e) => e.range]); + } + function ne(e, t) { + return X(e, t.locator); + } + function oe(e, t, r) { + const A = w(t) ? D(t) : t; + return null === r + ? `${l.prettyDescriptor(e, A)} → ${a.mark(e).Cross}` + : A.identHash === r.identHash + ? `${l.prettyDescriptor(e, A)} → ${ee(e, r.reference)}` + : `${l.prettyDescriptor(e, A)} → ${te(e, r)}`; + } + function ie(e, t, r) { + return null === r + ? '' + te(e, t) + : `${te(e, t)} (via ${l.prettyRange(e, r.range)})`; + } + function se(e) { + return 'node_modules/' + H(e); + } + }, + 72785: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + makeArchiveFromDirectory: () => h, + convertToZip: () => p, + extractArchiveTo: () => d, + }); + var A = r(78420), + n = r(46009), + o = r(90739), + i = r(43896), + s = r(65281), + a = r(59938), + c = r(31669), + g = r(78761), + l = r.n(g); + const u = (0, c.promisify)(l().gunzip); + async function h( + e, + { + baseFs: t = new A.S(), + prefixPath: r = n.LZ.root, + compressionLevel: a, + inMemory: c = !1, + } = {} + ) { + const g = await (0, s.getLibzipPromise)(); + let l; + if (c) l = new o.d(null, { libzip: g, level: a }); + else { + const e = await i.xfs.mktempPromise(), + t = n.y1.join(e, 'archive.zip'); + l = new o.d(t, { create: !0, libzip: g, level: a }); + } + const u = n.y1.resolve(n.LZ.root, r); + return ( + await l.copyPromise(u, e, { + baseFs: t, + stableTime: !0, + stableSort: !0, + }), + l + ); + } + async function p(e, t) { + const r = await i.xfs.mktempPromise(), + A = n.y1.join(r, 'archive.zip'), + { compressionLevel: a, ...c } = t; + return await d( + e, + new o.d(A, { + create: !0, + libzip: await (0, s.getLibzipPromise)(), + level: a, + }), + c + ); + } + async function d( + e, + t, + { stripComponents: r = 0, prefixPath: A = n.LZ.dot } = {} + ) { + const o = a.extract(); + o.on('entry', (e, o, i) => { + var s, a; + if ( + (function (e) { + if ('/' === e.name[0]) return !0; + const t = e.name.split(/\//g); + return !!t.some((e) => '..' === e) || t.length <= r; + })(e) + ) + return void i(); + const c = n.y1 + .normalize(n.cS.toPortablePath(e.name)) + .replace(/\/$/, '') + .split(/\//g); + if (c.length <= r) return o.resume(), void i(); + const g = c.slice(r).join('/'), + l = n.y1.join(A, g); + let u = 420; + switch ( + (('directory' !== e.type && + 0 == (73 & (null !== (s = e.mode) && void 0 !== s ? s : 0))) || + (u |= 73), + e.type) + ) { + case 'directory': + t.mkdirpSync(n.y1.dirname(l), { + chmod: 493, + utimes: [315532800, 315532800], + }), + t.mkdirSync(l), + t.chmodSync(l, u), + t.utimesSync(l, 315532800, 315532800), + i(); + break; + case 'file': + { + t.mkdirpSync(n.y1.dirname(l), { + chmod: 493, + utimes: [315532800, 315532800], + }); + const e = []; + o.on('data', (t) => e.push(t)), + o.on('end', () => { + t.writeFileSync(l, Buffer.concat(e)), + t.chmodSync(l, u), + t.utimesSync(l, 315532800, 315532800), + i(); + }); + } + break; + case 'symlink': + t.mkdirpSync(n.y1.dirname(l), { + chmod: 493, + utimes: [315532800, 315532800], + }), + t.symlinkSync(e.linkname, l), + null === (a = t.lutimesSync) || + void 0 === a || + a.call(t, l, 315532800, 315532800), + i(); + break; + default: + o.resume(), i(); + } + }); + const i = await u(e); + return await new Promise((e, r) => { + o.on('error', (e) => { + r(e); + }), + o.on('finish', () => { + e(t); + }), + o.end(i); + }); + } + }, + 85875: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + treeNodeToTreeify: () => o, + treeNodeToJson: () => i, + emitList: () => s, + emitTree: () => a, + }); + var A = r(94682), + n = r(71643); + function o(e, { configuration: t }) { + const r = {}, + A = (e, r) => { + const o = Array.isArray(e) ? e.entries() : Object.entries(e); + for (const [e, { label: i, value: s, children: a }] of o) { + const o = []; + void 0 !== i && o.push(n.applyStyle(t, i, n.Style.BOLD)), + void 0 !== s && o.push(n.pretty(t, s[0], s[1])), + 0 === o.length && + o.push(n.applyStyle(t, '' + e, n.Style.BOLD)); + const c = (r[o.join(': ')] = {}); + void 0 !== a && A(a, c); + } + }; + if (void 0 === e.children) + throw new Error('The root node must only contain children'); + return A(e.children, r), r; + } + function i(e) { + const t = (e) => { + var r; + if (void 0 === e.children) { + if (void 0 === e.value) + throw new Error( + 'Assertion failed: Expected a value to be set if the children are missing' + ); + return n.json(e.value[0], e.value[1]); + } + const A = Array.isArray(e.children) + ? e.children.entries() + : Object.entries( + null !== (r = e.children) && void 0 !== r ? r : {} + ), + o = Array.isArray(e.children) ? [] : {}; + for (const [e, r] of A) o[e] = t(r); + return void 0 === e.value + ? o + : { value: n.json(e.value[0], e.value[1]), children: o }; + }; + return t(e); + } + function s(e, { configuration: t, stdout: r, json: A }) { + a( + { children: e.map((e) => ({ value: e })) }, + { configuration: t, stdout: r, json: A } + ); + } + function a( + e, + { configuration: t, stdout: r, json: n, separators: s = 0 } + ) { + var a; + if (n) { + const t = Array.isArray(e.children) + ? e.children.values() + : Object.values( + null !== (a = e.children) && void 0 !== a ? a : {} + ); + for (const e of t) r.write(JSON.stringify(i(e)) + '\n'); + return; + } + let c = (0, A.asTree)(o(e, { configuration: t }), !1, !1); + if ( + (s >= 1 && + (c = c.replace(/^([├└]─)/gm, '│\n$1').replace(/^│\n/, '')), + s >= 2) + ) + for (let e = 0; e < 2; ++e) + c = c + .replace( + /^([│ ].{2}[├│ ].{2}[^\n]+\n)(([│ ]).{2}[├└].{2}[^\n]*\n[│ ].{2}[│ ].{2}[├└]─)/gm, + '$1$3 │\n$2' + ) + .replace(/^│\n/, ''); + if (s >= 3) + throw new Error( + 'Only the first two levels are accepted by treeUtils.emitTree' + ); + r.write(c); + } + }, + 32485: (e, t, r) => { + 'use strict'; + var A, n, o; + r.d(t, { Un: () => A, HN: () => n, _u: () => o }), + (function (e) { + (e.HARD = 'HARD'), (e.SOFT = 'SOFT'); + })(A || (A = {})), + (function (e) { + (e.Dependency = 'Dependency'), + (e.PeerDependency = 'PeerDependency'), + (e.PeerDependencyMeta = 'PeerDependencyMeta'); + })(n || (n = {})), + (function (e) { + (e.Inactive = 'inactive'), + (e.Redundant = 'redundant'), + (e.Active = 'active'); + })(o || (o = {})); + }, + 14626: (e, t, r) => { + 'use strict'; + r.d(t, { K: () => n }); + var A = r(42096); + class n extends A.p { + constructor(e, { baseFs: t, pathUtils: r }) { + super(r), (this.target = e), (this.baseFs = t); + } + getRealPath() { + return this.target; + } + getBaseFs() { + return this.baseFs; + } + mapFromBase(e) { + return e; + } + mapToBase(e) { + return e; + } + } + }, + 75448: (e, t, r) => { + 'use strict'; + r.d(t, { M: () => i }); + var A = r(78420), + n = r(42096), + o = r(46009); + class i extends n.p { + constructor(e, { baseFs: t = new A.S() } = {}) { + super(o.y1), + (this.target = this.pathUtils.normalize(e)), + (this.baseFs = t); + } + getRealPath() { + return this.pathUtils.resolve( + this.baseFs.getRealPath(), + this.target + ); + } + resolve(e) { + return this.pathUtils.isAbsolute(e) + ? o.y1.normalize(e) + : this.baseFs.resolve(o.y1.join(this.target, e)); + } + mapFromBase(e) { + return e; + } + mapToBase(e) { + return this.pathUtils.isAbsolute(e) + ? e + : this.pathUtils.join(this.target, e); + } + } + }, + 5944: (e, t, r) => { + 'use strict'; + r.d(t, { fS: () => g, uY: () => c, qH: () => l }); + var A = r(12087), + n = r(35747), + o = r.n(n), + i = r(46009); + const s = new Date(3155328e5); + async function a(e, t, r, A, n, c, g, l) { + var u, h; + const p = await (async function (e, t) { + try { + return await e.lstatPromise(t); + } catch (e) { + return null; + } + })(A, n), + d = await c.lstatPromise(g), + C = l.stableTime ? { mtime: s, atime: s } : d; + let f; + switch (!0) { + case d.isDirectory(): + f = await (async function (e, t, r, A, n, o, i, s, c, g) { + if (null !== o && !o.isDirectory()) { + if (!g.overwrite) return !1; + e.push(async () => A.removePromise(n)), (o = null); + } + let l = !1; + null === o && + (e.push(async () => A.mkdirPromise(n, { mode: c.mode })), + (l = !0)); + const u = await i.readdirPromise(s); + if (g.stableSort) + for (const o of u.sort()) + (await a( + e, + t, + r, + A, + A.pathUtils.join(n, o), + i, + i.pathUtils.join(s, o), + g + )) && (l = !0); + else { + ( + await Promise.all( + u.map(async (o) => { + await a( + e, + t, + r, + A, + A.pathUtils.join(n, o), + i, + i.pathUtils.join(s, o), + g + ); + }) + ) + ).some((e) => e) && (l = !0); + } + return l; + })(e, t, r, A, n, p, c, g, d, l); + break; + case d.isFile(): + f = await (async function (e, t, r, A, n, i, s, a, c, g) { + if (null !== i) { + if (!g.overwrite) return !1; + e.push(async () => A.removePromise(n)), (i = null); + } + const l = + A === s + ? async () => + A.copyFilePromise(a, n, o().constants.COPYFILE_FICLONE) + : async () => + A.writeFilePromise(n, await s.readFilePromise(a)); + return e.push(async () => l()), !0; + })(e, 0, 0, A, n, p, c, g, 0, l); + break; + case d.isSymbolicLink(): + f = await (async function (e, t, r, A, n, o, s, a, c, g) { + if (null !== o) { + if (!g.overwrite) return !1; + e.push(async () => A.removePromise(n)), (o = null); + } + return ( + e.push(async () => { + await A.symlinkPromise( + (0, i.CI)(A.pathUtils, await s.readlinkPromise(a)), + n + ); + }), + !0 + ); + })(e, 0, 0, A, n, p, c, g, 0, l); + break; + default: + throw new Error(`Unsupported file type (${d.mode})`); + } + return ( + (f || + (null === (u = null == p ? void 0 : p.mtime) || void 0 === u + ? void 0 + : u.getTime()) !== C.mtime.getTime() || + (null === (h = null == p ? void 0 : p.atime) || void 0 === h + ? void 0 + : h.getTime()) !== C.atime.getTime()) && + (t.push(() => r(n, C.atime, C.mtime)), (f = !0)), + (null !== p && (511 & p.mode) == (511 & d.mode)) || + (t.push(() => A.chmodPromise(n, 511 & d.mode)), (f = !0)), + f + ); + } + class c { + constructor(e) { + this.pathUtils = e; + } + async *genTraversePromise(e, { stableSort: t = !1 } = {}) { + const r = [e]; + for (; r.length > 0; ) { + const e = r.shift(); + if ((await this.lstatPromise(e)).isDirectory()) { + const A = await this.readdirPromise(e); + if (!t) throw new Error('Not supported'); + for (const t of A.sort()) r.push(this.pathUtils.join(e, t)); + } else yield e; + } + } + async removePromise( + e, + { recursive: t = !0, maxRetries: r = 5 } = {} + ) { + let A; + try { + A = await this.lstatPromise(e); + } catch (e) { + if ('ENOENT' === e.code) return; + throw e; + } + if (A.isDirectory()) { + if (t) + for (const t of await this.readdirPromise(e)) + await this.removePromise(this.pathUtils.resolve(e, t)); + let A = 0; + do { + try { + await this.rmdirPromise(e); + break; + } catch (e) { + if ('EBUSY' === e.code || 'ENOTEMPTY' === e.code) { + if (0 === r) break; + await new Promise((e) => setTimeout(e, 100 * A)); + continue; + } + throw e; + } + } while (A++ < r); + } else await this.unlinkPromise(e); + } + removeSync(e, { recursive: t = !0 } = {}) { + let r; + try { + r = this.lstatSync(e); + } catch (e) { + if ('ENOENT' === e.code) return; + throw e; + } + if (r.isDirectory()) { + if (t) + for (const t of this.readdirSync(e)) + this.removeSync(this.pathUtils.resolve(e, t)); + this.rmdirSync(e); + } else this.unlinkSync(e); + } + async mkdirpPromise(e, { chmod: t, utimes: r } = {}) { + if ((e = this.resolve(e)) === this.pathUtils.dirname(e)) return; + const A = e.split(this.pathUtils.sep); + for (let e = 2; e <= A.length; ++e) { + const n = A.slice(0, e).join(this.pathUtils.sep); + if (!this.existsSync(n)) { + try { + await this.mkdirPromise(n); + } catch (e) { + if ('EEXIST' === e.code) continue; + throw e; + } + if ((null != t && (await this.chmodPromise(n, t)), null != r)) + await this.utimesPromise(n, r[0], r[1]); + else { + const e = await this.statPromise(this.pathUtils.dirname(n)); + await this.utimesPromise(n, e.atime, e.mtime); + } + } + } + } + mkdirpSync(e, { chmod: t, utimes: r } = {}) { + if ((e = this.resolve(e)) === this.pathUtils.dirname(e)) return; + const A = e.split(this.pathUtils.sep); + for (let e = 2; e <= A.length; ++e) { + const n = A.slice(0, e).join(this.pathUtils.sep); + if (!this.existsSync(n)) { + try { + this.mkdirSync(n); + } catch (e) { + if ('EEXIST' === e.code) continue; + throw e; + } + if ((null != t && this.chmodSync(n, t), null != r)) + this.utimesSync(n, r[0], r[1]); + else { + const e = this.statSync(this.pathUtils.dirname(n)); + this.utimesSync(n, e.atime, e.mtime); + } + } + } + } + async copyPromise( + e, + t, + { + baseFs: r = this, + overwrite: A = !0, + stableSort: n = !1, + stableTime: o = !1, + } = {} + ) { + return await (async function (e, t, r, A, n) { + const o = e.pathUtils.normalize(t), + i = r.pathUtils.normalize(A), + s = [], + c = []; + await e.mkdirPromise(e.pathUtils.dirname(t), { recursive: !0 }); + const g = + 'function' == typeof e.lutimesPromise + ? e.lutimesPromise.bind(e) + : e.utimesPromise.bind(e); + await a(s, c, g, e, o, r, i, n); + for (const e of s) await e(); + await Promise.all(c.map((e) => e())); + })(this, e, r, t, { overwrite: A, stableSort: n, stableTime: o }); + } + copySync(e, t, { baseFs: r = this, overwrite: A = !0 } = {}) { + const n = r.lstatSync(t), + o = this.existsSync(e); + if (n.isDirectory()) { + this.mkdirpSync(e); + const n = r.readdirSync(t); + for (const o of n) + this.copySync( + this.pathUtils.join(e, o), + r.pathUtils.join(t, o), + { baseFs: r, overwrite: A } + ); + } else if (n.isFile()) { + if (!o || A) { + o && this.removeSync(e); + const A = r.readFileSync(t); + this.writeFileSync(e, A); + } + } else { + if (!n.isSymbolicLink()) + throw new Error( + `Unsupported file type (file: ${t}, mode: 0o${n.mode + .toString(8) + .padStart(6, '0')})` + ); + if (!o || A) { + o && this.removeSync(e); + const A = r.readlinkSync(t); + this.symlinkSync((0, i.CI)(this.pathUtils, A), e); + } + } + const s = 511 & n.mode; + this.chmodSync(e, s); + } + async changeFilePromise(e, t, r = {}) { + return Buffer.isBuffer(t) + ? this.changeFileBufferPromise(e, t) + : this.changeFileTextPromise(e, t, r); + } + async changeFileBufferPromise(e, t) { + let r = Buffer.alloc(0); + try { + r = await this.readFilePromise(e); + } catch (e) {} + 0 !== Buffer.compare(r, t) && (await this.writeFilePromise(e, t)); + } + async changeFileTextPromise(e, t, { automaticNewlines: r } = {}) { + let A = ''; + try { + A = await this.readFilePromise(e, 'utf8'); + } catch (e) {} + const n = r ? l(A, t) : t; + A !== n && (await this.writeFilePromise(e, n)); + } + changeFileSync(e, t, r = {}) { + return Buffer.isBuffer(t) + ? this.changeFileBufferSync(e, t) + : this.changeFileTextSync(e, t, r); + } + changeFileBufferSync(e, t) { + let r = Buffer.alloc(0); + try { + r = this.readFileSync(e); + } catch (e) {} + 0 !== Buffer.compare(r, t) && this.writeFileSync(e, t); + } + changeFileTextSync(e, t, { automaticNewlines: r = !1 } = {}) { + let A = ''; + try { + A = this.readFileSync(e, 'utf8'); + } catch (e) {} + const n = r ? l(A, t) : t; + A !== n && this.writeFileSync(e, n); + } + async movePromise(e, t) { + try { + await this.renamePromise(e, t); + } catch (r) { + if ('EXDEV' !== r.code) throw r; + await this.copyPromise(t, e), await this.removePromise(e); + } + } + moveSync(e, t) { + try { + this.renameSync(e, t); + } catch (r) { + if ('EXDEV' !== r.code) throw r; + this.copySync(t, e), this.removeSync(e); + } + } + async lockPromise(e, t) { + const r = e + '.flock', + A = Date.now(); + let n = null; + const o = async () => { + let e; + try { + [e] = await this.readJsonPromise(r); + } catch (e) { + return Date.now() - A < 500; + } + try { + return process.kill(e, 0), !0; + } catch (e) { + return !1; + } + }; + for (; null === n; ) + try { + n = await this.openPromise(r, 'wx'); + } catch (e) { + if ('EEXIST' !== e.code) throw e; + if (!(await o())) + try { + await this.unlinkPromise(r); + continue; + } catch (e) {} + if (!(Date.now() - A < 6e4)) + throw new Error( + `Couldn't acquire a lock in a reasonable time (via ${r})` + ); + await new Promise((e) => setTimeout(e, 1e3 / 60)); + } + await this.writePromise(n, JSON.stringify([process.pid])); + try { + return await t(); + } finally { + try { + await this.closePromise(n), await this.unlinkPromise(r); + } catch (e) {} + } + } + async readJsonPromise(e) { + const t = await this.readFilePromise(e, 'utf8'); + try { + return JSON.parse(t); + } catch (t) { + throw ((t.message += ` (in ${e})`), t); + } + } + readJsonSync(e) { + const t = this.readFileSync(e, 'utf8'); + try { + return JSON.parse(t); + } catch (t) { + throw ((t.message += ` (in ${e})`), t); + } + } + async writeJsonPromise(e, t) { + return await this.writeFilePromise( + e, + JSON.stringify(t, null, 2) + '\n' + ); + } + writeJsonSync(e, t) { + return this.writeFileSync(e, JSON.stringify(t, null, 2) + '\n'); + } + async preserveTimePromise(e, t) { + const r = await this.lstatPromise(e), + A = await t(); + void 0 !== A && (e = A), + this.lutimesPromise + ? await this.lutimesPromise(e, r.atime, r.mtime) + : r.isSymbolicLink() || + (await this.utimesPromise(e, r.atime, r.mtime)); + } + async preserveTimeSync(e, t) { + const r = this.lstatSync(e), + A = t(); + void 0 !== A && (e = A), + this.lutimesSync + ? this.lutimesSync(e, r.atime, r.mtime) + : r.isSymbolicLink() || this.utimesSync(e, r.atime, r.mtime); + } + } + c.DEFAULT_TIME = 315532800; + class g extends c { + constructor() { + super(i.y1); + } + } + function l(e, t) { + return t.replace( + /\r?\n/g, + (function (e) { + const t = e.match(/\r?\n/g); + if (null === t) return A.EOL; + const r = t.filter((e) => '\r\n' === e).length; + return r > t.length - r ? '\r\n' : '\n'; + })(e) + ); + } + }, + 10489: (e, t, r) => { + 'use strict'; + r.d(t, { n: () => s }); + var A = r(78420), + n = r(42096), + o = r(46009); + const i = o.LZ.root; + class s extends n.p { + constructor(e, { baseFs: t = new A.S() } = {}) { + super(o.y1), + (this.target = this.pathUtils.resolve(o.LZ.root, e)), + (this.baseFs = t); + } + getRealPath() { + return this.pathUtils.resolve( + this.baseFs.getRealPath(), + this.pathUtils.relative(o.LZ.root, this.target) + ); + } + getTarget() { + return this.target; + } + getBaseFs() { + return this.baseFs; + } + mapToBase(e) { + const t = this.pathUtils.normalize(e); + if (this.pathUtils.isAbsolute(e)) + return this.pathUtils.resolve( + this.target, + this.pathUtils.relative(i, e) + ); + if (t.match(/^\.\.\/?/)) + throw new Error( + `Resolving this path (${e}) would escape the jail` + ); + return this.pathUtils.resolve(this.target, e); + } + mapFromBase(e) { + return this.pathUtils.resolve( + i, + this.pathUtils.relative(this.target, e) + ); + } + } + }, + 15037: (e, t, r) => { + 'use strict'; + r.d(t, { v: () => n }); + var A = r(42096); + class n extends A.p { + constructor(e, t) { + super(t), (this.instance = null), (this.factory = e); + } + get baseFs() { + return ( + this.instance || (this.instance = this.factory()), this.instance + ); + } + set baseFs(e) { + this.instance = e; + } + mapFromBase(e) { + return e; + } + mapToBase(e) { + return e; + } + } + }, + 78420: (e, t, r) => { + 'use strict'; + r.d(t, { S: () => a }); + var A = r(35747), + n = r.n(A), + o = r(5944), + i = r(26984), + s = r(46009); + class a extends o.fS { + constructor(e = n()) { + super(), + (this.realFs = e), + void 0 !== this.realFs.lutimes && + ((this.lutimesPromise = this.lutimesPromiseImpl), + (this.lutimesSync = this.lutimesSyncImpl)); + } + getExtractHint() { + return !1; + } + getRealPath() { + return s.LZ.root; + } + resolve(e) { + return s.y1.resolve(e); + } + async openPromise(e, t, r) { + return await new Promise((A, n) => { + this.realFs.open( + s.cS.fromPortablePath(e), + t, + r, + this.makeCallback(A, n) + ); + }); + } + openSync(e, t, r) { + return this.realFs.openSync(s.cS.fromPortablePath(e), t, r); + } + async opendirPromise(e, t) { + return await new Promise((r, A) => { + void 0 !== t + ? this.realFs.opendir( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ) + : this.realFs.opendir( + s.cS.fromPortablePath(e), + this.makeCallback(r, A) + ); + }).then((t) => + Object.defineProperty(t, 'path', { + value: e, + configurable: !0, + writable: !0, + }) + ); + } + opendirSync(e, t) { + const r = + void 0 !== t + ? this.realFs.opendirSync(s.cS.fromPortablePath(e), t) + : this.realFs.opendirSync(s.cS.fromPortablePath(e)); + return Object.defineProperty(r, 'path', { + value: e, + configurable: !0, + writable: !0, + }); + } + async readPromise(e, t, r = 0, A = 0, n = -1) { + return await new Promise((o, i) => { + this.realFs.read(e, t, r, A, n, (e, t) => { + e ? i(e) : o(t); + }); + }); + } + readSync(e, t, r, A, n) { + return this.realFs.readSync(e, t, r, A, n); + } + async writePromise(e, t, r, A, n) { + return await new Promise((o, i) => + 'string' == typeof t + ? this.realFs.write(e, t, r, this.makeCallback(o, i)) + : this.realFs.write(e, t, r, A, n, this.makeCallback(o, i)) + ); + } + writeSync(e, t, r, A, n) { + return 'string' == typeof t + ? this.realFs.writeSync(e, t, r) + : this.realFs.writeSync(e, t, r, A, n); + } + async closePromise(e) { + await new Promise((t, r) => { + this.realFs.close(e, this.makeCallback(t, r)); + }); + } + closeSync(e) { + this.realFs.closeSync(e); + } + createReadStream(e, t) { + const r = null !== e ? s.cS.fromPortablePath(e) : e; + return this.realFs.createReadStream(r, t); + } + createWriteStream(e, t) { + const r = null !== e ? s.cS.fromPortablePath(e) : e; + return this.realFs.createWriteStream(r, t); + } + async realpathPromise(e) { + return await new Promise((t, r) => { + this.realFs.realpath( + s.cS.fromPortablePath(e), + {}, + this.makeCallback(t, r) + ); + }).then((e) => s.cS.toPortablePath(e)); + } + realpathSync(e) { + return s.cS.toPortablePath( + this.realFs.realpathSync(s.cS.fromPortablePath(e), {}) + ); + } + async existsPromise(e) { + return await new Promise((t) => { + this.realFs.exists(s.cS.fromPortablePath(e), t); + }); + } + accessSync(e, t) { + return this.realFs.accessSync(s.cS.fromPortablePath(e), t); + } + async accessPromise(e, t) { + return await new Promise((r, A) => { + this.realFs.access( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ); + }); + } + existsSync(e) { + return this.realFs.existsSync(s.cS.fromPortablePath(e)); + } + async statPromise(e) { + return await new Promise((t, r) => { + this.realFs.stat( + s.cS.fromPortablePath(e), + this.makeCallback(t, r) + ); + }); + } + statSync(e) { + return this.realFs.statSync(s.cS.fromPortablePath(e)); + } + async lstatPromise(e) { + return await new Promise((t, r) => { + this.realFs.lstat( + s.cS.fromPortablePath(e), + this.makeCallback(t, r) + ); + }); + } + lstatSync(e) { + return this.realFs.lstatSync(s.cS.fromPortablePath(e)); + } + async chmodPromise(e, t) { + return await new Promise((r, A) => { + this.realFs.chmod( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ); + }); + } + chmodSync(e, t) { + return this.realFs.chmodSync(s.cS.fromPortablePath(e), t); + } + async chownPromise(e, t, r) { + return await new Promise((A, n) => { + this.realFs.chown( + s.cS.fromPortablePath(e), + t, + r, + this.makeCallback(A, n) + ); + }); + } + chownSync(e, t, r) { + return this.realFs.chownSync(s.cS.fromPortablePath(e), t, r); + } + async renamePromise(e, t) { + return await new Promise((r, A) => { + this.realFs.rename( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t), + this.makeCallback(r, A) + ); + }); + } + renameSync(e, t) { + return this.realFs.renameSync( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t) + ); + } + async copyFilePromise(e, t, r = 0) { + return await new Promise((A, n) => { + this.realFs.copyFile( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t), + r, + this.makeCallback(A, n) + ); + }); + } + copyFileSync(e, t, r = 0) { + return this.realFs.copyFileSync( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t), + r + ); + } + async appendFilePromise(e, t, r) { + return await new Promise((A, n) => { + const o = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + r + ? this.realFs.appendFile(o, t, r, this.makeCallback(A, n)) + : this.realFs.appendFile(o, t, this.makeCallback(A, n)); + }); + } + appendFileSync(e, t, r) { + const A = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + r + ? this.realFs.appendFileSync(A, t, r) + : this.realFs.appendFileSync(A, t); + } + async writeFilePromise(e, t, r) { + return await new Promise((A, n) => { + const o = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + r + ? this.realFs.writeFile(o, t, r, this.makeCallback(A, n)) + : this.realFs.writeFile(o, t, this.makeCallback(A, n)); + }); + } + writeFileSync(e, t, r) { + const A = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + r + ? this.realFs.writeFileSync(A, t, r) + : this.realFs.writeFileSync(A, t); + } + async unlinkPromise(e) { + return await new Promise((t, r) => { + this.realFs.unlink( + s.cS.fromPortablePath(e), + this.makeCallback(t, r) + ); + }); + } + unlinkSync(e) { + return this.realFs.unlinkSync(s.cS.fromPortablePath(e)); + } + async utimesPromise(e, t, r) { + return await new Promise((A, n) => { + this.realFs.utimes( + s.cS.fromPortablePath(e), + t, + r, + this.makeCallback(A, n) + ); + }); + } + utimesSync(e, t, r) { + this.realFs.utimesSync(s.cS.fromPortablePath(e), t, r); + } + async lutimesPromiseImpl(e, t, r) { + const A = this.realFs.lutimes; + if (void 0 === A) + throw (0, i.bk)('unavailable Node binding', `lutimes '${e}'`); + return await new Promise((n, o) => { + A.call( + this.realFs, + s.cS.fromPortablePath(e), + t, + r, + this.makeCallback(n, o) + ); + }); + } + lutimesSyncImpl(e, t, r) { + const A = this.realFs.lutimesSync; + if (void 0 === A) + throw (0, i.bk)('unavailable Node binding', `lutimes '${e}'`); + A.call(this.realFs, s.cS.fromPortablePath(e), t, r); + } + async mkdirPromise(e, t) { + return await new Promise((r, A) => { + this.realFs.mkdir( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ); + }); + } + mkdirSync(e, t) { + return this.realFs.mkdirSync(s.cS.fromPortablePath(e), t); + } + async rmdirPromise(e, t) { + return await new Promise((r, A) => { + t + ? this.realFs.rmdir( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ) + : this.realFs.rmdir( + s.cS.fromPortablePath(e), + this.makeCallback(r, A) + ); + }); + } + rmdirSync(e, t) { + return this.realFs.rmdirSync(s.cS.fromPortablePath(e), t); + } + async linkPromise(e, t) { + return await new Promise((r, A) => { + this.realFs.link( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t), + this.makeCallback(r, A) + ); + }); + } + linkSync(e, t) { + return this.realFs.linkSync( + s.cS.fromPortablePath(e), + s.cS.fromPortablePath(t) + ); + } + async symlinkPromise(e, t, r) { + const A = r || (e.endsWith('/') ? 'dir' : 'file'); + return await new Promise((r, n) => { + this.realFs.symlink( + s.cS.fromPortablePath(e.replace(/\/+$/, '')), + s.cS.fromPortablePath(t), + A, + this.makeCallback(r, n) + ); + }); + } + symlinkSync(e, t, r) { + const A = r || (e.endsWith('/') ? 'dir' : 'file'); + return this.realFs.symlinkSync( + s.cS.fromPortablePath(e.replace(/\/+$/, '')), + s.cS.fromPortablePath(t), + A + ); + } + async readFilePromise(e, t) { + return await new Promise((r, A) => { + const n = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + this.realFs.readFile(n, t, this.makeCallback(r, A)); + }); + } + readFileSync(e, t) { + const r = 'string' == typeof e ? s.cS.fromPortablePath(e) : e; + return this.realFs.readFileSync(r, t); + } + async readdirPromise(e, { withFileTypes: t } = {}) { + return await new Promise((r, A) => { + t + ? this.realFs.readdir( + s.cS.fromPortablePath(e), + { withFileTypes: !0 }, + this.makeCallback(r, A) + ) + : this.realFs.readdir( + s.cS.fromPortablePath(e), + this.makeCallback((e) => r(e), A) + ); + }); + } + readdirSync(e, { withFileTypes: t } = {}) { + return t + ? this.realFs.readdirSync(s.cS.fromPortablePath(e), { + withFileTypes: !0, + }) + : this.realFs.readdirSync(s.cS.fromPortablePath(e)); + } + async readlinkPromise(e) { + return await new Promise((t, r) => { + this.realFs.readlink( + s.cS.fromPortablePath(e), + this.makeCallback(t, r) + ); + }).then((e) => s.cS.toPortablePath(e)); + } + readlinkSync(e) { + return s.cS.toPortablePath( + this.realFs.readlinkSync(s.cS.fromPortablePath(e)) + ); + } + async truncatePromise(e, t) { + return await new Promise((r, A) => { + this.realFs.truncate( + s.cS.fromPortablePath(e), + t, + this.makeCallback(r, A) + ); + }); + } + truncateSync(e, t) { + return this.realFs.truncateSync(s.cS.fromPortablePath(e), t); + } + watch(e, t, r) { + return this.realFs.watch(s.cS.fromPortablePath(e), t, r); + } + watchFile(e, t, r) { + return this.realFs.watchFile(s.cS.fromPortablePath(e), t, r); + } + unwatchFile(e, t) { + return this.realFs.unwatchFile(s.cS.fromPortablePath(e), t); + } + makeCallback(e, t) { + return (r, A) => { + r ? t(r) : e(A); + }; + } + } + }, + 39725: (e, t, r) => { + 'use strict'; + r.d(t, { i: () => o }); + var A = r(42096), + n = r(46009); + class o extends A.p { + constructor(e) { + super(n.cS), (this.baseFs = e); + } + mapFromBase(e) { + return n.cS.fromPortablePath(e); + } + mapToBase(e) { + return n.cS.toPortablePath(e); + } + } + }, + 42096: (e, t, r) => { + 'use strict'; + r.d(t, { p: () => n }); + var A = r(5944); + class n extends A.uY { + getExtractHint(e) { + return this.baseFs.getExtractHint(e); + } + resolve(e) { + return this.mapFromBase(this.baseFs.resolve(this.mapToBase(e))); + } + getRealPath() { + return this.mapFromBase(this.baseFs.getRealPath()); + } + async openPromise(e, t, r) { + return this.baseFs.openPromise(this.mapToBase(e), t, r); + } + openSync(e, t, r) { + return this.baseFs.openSync(this.mapToBase(e), t, r); + } + async opendirPromise(e, t) { + return Object.assign( + await this.baseFs.opendirPromise(this.mapToBase(e), t), + { path: e } + ); + } + opendirSync(e, t) { + return Object.assign( + this.baseFs.opendirSync(this.mapToBase(e), t), + { path: e } + ); + } + async readPromise(e, t, r, A, n) { + return await this.baseFs.readPromise(e, t, r, A, n); + } + readSync(e, t, r, A, n) { + return this.baseFs.readSync(e, t, r, A, n); + } + async writePromise(e, t, r, A, n) { + return 'string' == typeof t + ? await this.baseFs.writePromise(e, t, r) + : await this.baseFs.writePromise(e, t, r, A, n); + } + writeSync(e, t, r, A, n) { + return 'string' == typeof t + ? this.baseFs.writeSync(e, t, r) + : this.baseFs.writeSync(e, t, r, A, n); + } + async closePromise(e) { + return this.baseFs.closePromise(e); + } + closeSync(e) { + this.baseFs.closeSync(e); + } + createReadStream(e, t) { + return this.baseFs.createReadStream( + null !== e ? this.mapToBase(e) : e, + t + ); + } + createWriteStream(e, t) { + return this.baseFs.createWriteStream( + null !== e ? this.mapToBase(e) : e, + t + ); + } + async realpathPromise(e) { + return this.mapFromBase( + await this.baseFs.realpathPromise(this.mapToBase(e)) + ); + } + realpathSync(e) { + return this.mapFromBase( + this.baseFs.realpathSync(this.mapToBase(e)) + ); + } + async existsPromise(e) { + return this.baseFs.existsPromise(this.mapToBase(e)); + } + existsSync(e) { + return this.baseFs.existsSync(this.mapToBase(e)); + } + accessSync(e, t) { + return this.baseFs.accessSync(this.mapToBase(e), t); + } + async accessPromise(e, t) { + return this.baseFs.accessPromise(this.mapToBase(e), t); + } + async statPromise(e) { + return this.baseFs.statPromise(this.mapToBase(e)); + } + statSync(e) { + return this.baseFs.statSync(this.mapToBase(e)); + } + async lstatPromise(e) { + return this.baseFs.lstatPromise(this.mapToBase(e)); + } + lstatSync(e) { + return this.baseFs.lstatSync(this.mapToBase(e)); + } + async chmodPromise(e, t) { + return this.baseFs.chmodPromise(this.mapToBase(e), t); + } + chmodSync(e, t) { + return this.baseFs.chmodSync(this.mapToBase(e), t); + } + async chownPromise(e, t, r) { + return this.baseFs.chownPromise(this.mapToBase(e), t, r); + } + chownSync(e, t, r) { + return this.baseFs.chownSync(this.mapToBase(e), t, r); + } + async renamePromise(e, t) { + return this.baseFs.renamePromise( + this.mapToBase(e), + this.mapToBase(t) + ); + } + renameSync(e, t) { + return this.baseFs.renameSync(this.mapToBase(e), this.mapToBase(t)); + } + async copyFilePromise(e, t, r = 0) { + return this.baseFs.copyFilePromise( + this.mapToBase(e), + this.mapToBase(t), + r + ); + } + copyFileSync(e, t, r = 0) { + return this.baseFs.copyFileSync( + this.mapToBase(e), + this.mapToBase(t), + r + ); + } + async appendFilePromise(e, t, r) { + return this.baseFs.appendFilePromise(this.fsMapToBase(e), t, r); + } + appendFileSync(e, t, r) { + return this.baseFs.appendFileSync(this.fsMapToBase(e), t, r); + } + async writeFilePromise(e, t, r) { + return this.baseFs.writeFilePromise(this.fsMapToBase(e), t, r); + } + writeFileSync(e, t, r) { + return this.baseFs.writeFileSync(this.fsMapToBase(e), t, r); + } + async unlinkPromise(e) { + return this.baseFs.unlinkPromise(this.mapToBase(e)); + } + unlinkSync(e) { + return this.baseFs.unlinkSync(this.mapToBase(e)); + } + async utimesPromise(e, t, r) { + return this.baseFs.utimesPromise(this.mapToBase(e), t, r); + } + utimesSync(e, t, r) { + return this.baseFs.utimesSync(this.mapToBase(e), t, r); + } + async mkdirPromise(e, t) { + return this.baseFs.mkdirPromise(this.mapToBase(e), t); + } + mkdirSync(e, t) { + return this.baseFs.mkdirSync(this.mapToBase(e), t); + } + async rmdirPromise(e, t) { + return this.baseFs.rmdirPromise(this.mapToBase(e), t); + } + rmdirSync(e, t) { + return this.baseFs.rmdirSync(this.mapToBase(e), t); + } + async linkPromise(e, t) { + return this.baseFs.linkPromise( + this.mapToBase(e), + this.mapToBase(t) + ); + } + linkSync(e, t) { + return this.baseFs.linkSync(this.mapToBase(e), this.mapToBase(t)); + } + async symlinkPromise(e, t, r) { + return this.baseFs.symlinkPromise( + this.mapToBase(e), + this.mapToBase(t), + r + ); + } + symlinkSync(e, t, r) { + return this.baseFs.symlinkSync( + this.mapToBase(e), + this.mapToBase(t), + r + ); + } + async readFilePromise(e, t) { + return this.baseFs.readFilePromise(this.fsMapToBase(e), t); + } + readFileSync(e, t) { + return this.baseFs.readFileSync(this.fsMapToBase(e), t); + } + async readdirPromise(e, { withFileTypes: t } = {}) { + return this.baseFs.readdirPromise(this.mapToBase(e), { + withFileTypes: t, + }); + } + readdirSync(e, { withFileTypes: t } = {}) { + return this.baseFs.readdirSync(this.mapToBase(e), { + withFileTypes: t, + }); + } + async readlinkPromise(e) { + return this.mapFromBase( + await this.baseFs.readlinkPromise(this.mapToBase(e)) + ); + } + readlinkSync(e) { + return this.mapFromBase( + this.baseFs.readlinkSync(this.mapToBase(e)) + ); + } + async truncatePromise(e, t) { + return this.baseFs.truncatePromise(this.mapToBase(e), t); + } + truncateSync(e, t) { + return this.baseFs.truncateSync(this.mapToBase(e), t); + } + watch(e, t, r) { + return this.baseFs.watch(this.mapToBase(e), t, r); + } + watchFile(e, t, r) { + return this.baseFs.watchFile(this.mapToBase(e), t, r); + } + unwatchFile(e, t) { + return this.baseFs.unwatchFile(this.mapToBase(e), t); + } + fsMapToBase(e) { + return 'number' == typeof e ? e : this.mapToBase(e); + } + } + }, + 17674: (e, t, r) => { + 'use strict'; + r.d(t, { p: () => c }); + var A = r(78420), + n = r(42096), + o = r(46009); + const i = /^[0-9]+$/, + s = /^(\/(?:[^/]+\/)*?\$\$virtual)((?:\/((?:[^/]+-)?[a-f0-9]+)(?:\/([^/]+))?)?((?:\/.*)?))$/, + a = /^([^/]+-)?[a-f0-9]+$/; + class c extends n.p { + constructor({ baseFs: e = new A.S() } = {}) { + super(o.y1), (this.baseFs = e); + } + static makeVirtualPath(e, t, r) { + if ('$$virtual' !== o.y1.basename(e)) + throw new Error( + 'Assertion failed: Virtual folders must be named "$$virtual"' + ); + if (!o.y1.basename(t).match(a)) + throw new Error( + 'Assertion failed: Virtual components must be ended by an hexadecimal hash' + ); + const A = o.y1.relative(o.y1.dirname(e), r).split('/'); + let n = 0; + for (; n < A.length && '..' === A[n]; ) n += 1; + const i = A.slice(n); + return o.y1.join(e, t, String(n), ...i); + } + static resolveVirtual(e) { + const t = e.match(s); + if (!t || (!t[3] && t[5])) return e; + const r = o.y1.dirname(t[1]); + if (!t[3] || !t[4]) return r; + if (!i.test(t[4])) return e; + const A = Number(t[4]), + n = '../'.repeat(A), + a = t[5] || '.'; + return c.resolveVirtual(o.y1.join(r, n, a)); + } + getExtractHint(e) { + return this.baseFs.getExtractHint(e); + } + getRealPath() { + return this.baseFs.getRealPath(); + } + realpathSync(e) { + const t = e.match(s); + if (!t) return this.baseFs.realpathSync(e); + if (!t[5]) return e; + const r = this.baseFs.realpathSync(this.mapToBase(e)); + return c.makeVirtualPath(t[1], t[3], r); + } + async realpathPromise(e) { + const t = e.match(s); + if (!t) return await this.baseFs.realpathPromise(e); + if (!t[5]) return e; + const r = await this.baseFs.realpathPromise(this.mapToBase(e)); + return c.makeVirtualPath(t[1], t[3], r); + } + mapToBase(e) { + return c.resolveVirtual(e); + } + mapFromBase(e) { + return e; + } + } + }, + 90739: (e, t, r) => { + 'use strict'; + r.d(t, { k: () => C, d: () => f }); + var A = r(35747), + n = r(92413), + o = r(31669), + i = r(78761), + s = r.n(i), + a = r(5944), + c = r(78420), + g = r(19697), + l = r(38783), + u = r(22004), + h = r(26984), + p = r(46009), + d = r(65760); + const C = 'mixed'; + class f extends a.fS { + constructor(e, t) { + super(), + (this.lzSource = null), + (this.listings = new Map()), + (this.entries = new Map()), + (this.fileSources = new Map()), + (this.fds = new Map()), + (this.nextFd = 0), + (this.ready = !1), + (this.readOnly = !1), + (this.libzip = t.libzip); + const r = t; + if ( + ((this.level = void 0 !== r.level ? r.level : C), + null === e && + (e = Buffer.from([ + 80, + 75, + 5, + 6, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ])), + 'string' == typeof e) + ) { + const { baseFs: t = new c.S() } = r; + (this.baseFs = t), (this.path = e); + } else (this.path = null), (this.baseFs = null); + if (t.stats) this.stats = t.stats; + else if ('string' == typeof e) + try { + this.stats = this.baseFs.statSync(e); + } catch (e) { + if ('ENOENT' !== e.code || !r.create) throw e; + this.stats = d.makeDefaultStats(); + } + else this.stats = d.makeDefaultStats(); + const A = this.libzip.malloc(4); + try { + let n = 0; + if ( + ('string' == typeof e && + r.create && + (n |= this.libzip.ZIP_CREATE | this.libzip.ZIP_TRUNCATE), + t.readOnly && + ((n |= this.libzip.ZIP_RDONLY), (this.readOnly = !0)), + 'string' == typeof e) + ) + this.zip = this.libzip.open(p.cS.fromPortablePath(e), n, A); + else { + const t = this.allocateUnattachedSource(e); + try { + (this.zip = this.libzip.openFromSource(t, n, A)), + (this.lzSource = t); + } catch (e) { + throw (this.libzip.source.free(t), e); + } + } + if (0 === this.zip) { + const e = this.libzip.struct.errorS(); + throw ( + (this.libzip.error.initWithCode( + e, + this.libzip.getValue(A, 'i32') + ), + this.makeLibzipError(e)) + ); + } + } finally { + this.libzip.free(A); + } + this.listings.set(p.LZ.root, new Set()); + const n = this.libzip.getNumEntries(this.zip, 0); + for (let e = 0; e < n; ++e) { + const t = this.libzip.getName(this.zip, e, 0); + if (p.y1.isAbsolute(t)) continue; + const r = p.y1.resolve(p.LZ.root, t); + this.registerEntry(r, e), + t.endsWith('/') && this.registerListing(r); + } + if ( + ((this.symlinkCount = this.libzip.ext.countSymlinks(this.zip)), + -1 === this.symlinkCount) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + this.ready = !0; + } + makeLibzipError(e) { + const t = this.libzip.struct.errorCodeZip(e), + r = this.libzip.error.strerror(e), + A = new h.Yn(r, this.libzip.errors[t]); + if (t === this.libzip.errors.ZIP_ER_CHANGED) + throw new Error( + 'Assertion failed: Unexpected libzip error: ' + A.message + ); + return A; + } + getExtractHint(e) { + for (const t of this.entries.keys()) { + const r = this.pathUtils.extname(t); + if (e.relevantExtensions.has(r)) return !0; + } + return !1; + } + getAllFiles() { + return Array.from(this.entries.keys()); + } + getRealPath() { + if (!this.path) + throw new Error( + "ZipFS don't have real paths when loaded from a buffer" + ); + return this.path; + } + getBufferAndClose() { + if ((this.prepareClose(), !this.lzSource)) + throw new Error('ZipFS was not created from a Buffer'); + try { + if ( + (this.libzip.source.keep(this.lzSource), + -1 === this.libzip.close(this.zip)) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + if (-1 === this.libzip.source.open(this.lzSource)) + throw this.makeLibzipError( + this.libzip.source.error(this.lzSource) + ); + if ( + -1 === + this.libzip.source.seek( + this.lzSource, + 0, + 0, + this.libzip.SEEK_END + ) + ) + throw this.makeLibzipError( + this.libzip.source.error(this.lzSource) + ); + const e = this.libzip.source.tell(this.lzSource); + if (-1 === e) + throw this.makeLibzipError( + this.libzip.source.error(this.lzSource) + ); + if ( + -1 === + this.libzip.source.seek( + this.lzSource, + 0, + 0, + this.libzip.SEEK_SET + ) + ) + throw this.makeLibzipError( + this.libzip.source.error(this.lzSource) + ); + const t = this.libzip.malloc(e); + if (!t) throw new Error("Couldn't allocate enough memory"); + try { + const r = this.libzip.source.read(this.lzSource, t, e); + if (-1 === r) + throw this.makeLibzipError( + this.libzip.source.error(this.lzSource) + ); + if (r < e) throw new Error('Incomplete read'); + if (r > e) throw new Error('Overread'); + const A = this.libzip.HEAPU8.subarray(t, t + e); + return Buffer.from(A); + } finally { + this.libzip.free(t); + } + } finally { + this.libzip.source.close(this.lzSource), + this.libzip.source.free(this.lzSource), + (this.ready = !1); + } + } + prepareClose() { + if (!this.ready) throw h.Vw('archive closed, close'); + (0, l.L)(this); + } + saveAndClose() { + if (!this.path || !this.baseFs) + throw new Error( + 'ZipFS cannot be saved and must be discarded when loaded from a buffer' + ); + if ((this.prepareClose(), this.readOnly)) + return void this.discardAndClose(); + const e = this.baseFs.existsSync(this.path) + ? 511 & this.baseFs.statSync(this.path).mode + : null; + if (-1 === this.libzip.close(this.zip)) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + null === e + ? this.baseFs.chmodSync(this.path, this.stats.mode) + : e !== (511 & this.baseFs.statSync(this.path).mode) && + this.baseFs.chmodSync(this.path, e), + (this.ready = !1); + } + discardAndClose() { + this.prepareClose(), + this.libzip.discard(this.zip), + (this.ready = !1); + } + resolve(e) { + return p.y1.resolve(p.LZ.root, e); + } + async openPromise(e, t, r) { + return this.openSync(e, t, r); + } + openSync(e, t, r) { + const A = this.nextFd++; + return this.fds.set(A, { cursor: 0, p: e }), A; + } + hasOpenFileHandles() { + return !!this.fds.size; + } + async opendirPromise(e, t) { + return this.opendirSync(e, t); + } + opendirSync(e, t = {}) { + const r = this.resolveFilename(`opendir '${e}'`, e); + if (!this.entries.has(r) && !this.listings.has(r)) + throw h.z6(`opendir '${e}'`); + const A = this.listings.get(r); + if (!A) throw h.Ab(`opendir '${e}'`); + const n = [...A], + o = this.openSync(r, 'r'); + return (0, g.a)(this, r, n, { + onClose: () => { + this.closeSync(o); + }, + }); + } + async readPromise(e, t, r, A, n) { + return this.readSync(e, t, r, A, n); + } + readSync(e, t, r = 0, A = 0, n = -1) { + const o = this.fds.get(e); + if (void 0 === o) throw h.Ch('read'); + let i; + i = -1 === n || null === n ? o.cursor : n; + const s = this.readFileSync(o.p); + s.copy(t, r, i, i + A); + const a = Math.max(0, Math.min(s.length - i, A)); + return (-1 !== n && null !== n) || (o.cursor += a), a; + } + async writePromise(e, t, r, A, n) { + return 'string' == typeof t + ? this.writeSync(e, t, n) + : this.writeSync(e, t, r, A, n); + } + writeSync(e, t, r, A, n) { + if (void 0 === this.fds.get(e)) throw h.Ch('read'); + throw new Error('Unimplemented'); + } + async closePromise(e) { + return this.closeSync(e); + } + closeSync(e) { + if (void 0 === this.fds.get(e)) throw h.Ch('read'); + this.fds.delete(e); + } + createReadStream(e, { encoding: t } = {}) { + if (null === e) throw new Error('Unimplemented'); + const r = this.openSync(e, 'r'), + A = Object.assign( + new n.PassThrough({ + emitClose: !0, + autoDestroy: !0, + destroy: (e, t) => { + clearImmediate(o), this.closeSync(r), t(e); + }, + }), + { + close() { + A.destroy(); + }, + bytesRead: 0, + path: e, + } + ), + o = setImmediate(async () => { + try { + const r = await this.readFilePromise(e, t); + (A.bytesRead = r.length), A.end(r); + } catch (e) { + A.destroy(e); + } + }); + return A; + } + createWriteStream(e, { encoding: t } = {}) { + if (this.readOnly) throw h.YW(`open '${e}'`); + if (null === e) throw new Error('Unimplemented'); + const r = [], + A = this.openSync(e, 'w'), + o = Object.assign( + new n.PassThrough({ + autoDestroy: !0, + emitClose: !0, + destroy: (n, o) => { + try { + n + ? o(n) + : (this.writeFileSync(e, Buffer.concat(r), t), o(null)); + } catch (e) { + o(e); + } finally { + this.closeSync(A); + } + }, + }), + { + bytesWritten: 0, + path: e, + close() { + o.destroy(); + }, + } + ); + return ( + o.on('data', (e) => { + const t = Buffer.from(e); + (o.bytesWritten += t.length), r.push(t); + }), + o + ); + } + async realpathPromise(e) { + return this.realpathSync(e); + } + realpathSync(e) { + const t = this.resolveFilename(`lstat '${e}'`, e); + if (!this.entries.has(t) && !this.listings.has(t)) + throw h.z6(`lstat '${e}'`); + return t; + } + async existsPromise(e) { + return this.existsSync(e); + } + existsSync(e) { + if (!this.ready) throw h.Vw(`archive closed, existsSync '${e}'`); + if (0 === this.symlinkCount) { + const t = p.y1.resolve(p.LZ.root, e); + return this.entries.has(t) || this.listings.has(t); + } + let t; + try { + t = this.resolveFilename(`stat '${e}'`, e); + } catch (e) { + return !1; + } + return this.entries.has(t) || this.listings.has(t); + } + async accessPromise(e, t) { + return this.accessSync(e, t); + } + accessSync(e, t = A.constants.F_OK) { + const r = this.resolveFilename(`access '${e}'`, e); + if (!this.entries.has(r) && !this.listings.has(r)) + throw h.z6(`access '${e}'`); + if (this.readOnly && t & A.constants.W_OK) + throw h.YW(`access '${e}'`); + } + async statPromise(e) { + return this.statSync(e); + } + statSync(e) { + const t = this.resolveFilename(`stat '${e}'`, e); + if (!this.entries.has(t) && !this.listings.has(t)) + throw h.z6(`stat '${e}'`); + if ('/' === e[e.length - 1] && !this.listings.has(t)) + throw h.Ab(`stat '${e}'`); + return this.statImpl(`stat '${e}'`, t); + } + async lstatPromise(e) { + return this.lstatSync(e); + } + lstatSync(e) { + const t = this.resolveFilename(`lstat '${e}'`, e, !1); + if (!this.entries.has(t) && !this.listings.has(t)) + throw h.z6(`lstat '${e}'`); + if ('/' === e[e.length - 1] && !this.listings.has(t)) + throw h.Ab(`lstat '${e}'`); + return this.statImpl(`lstat '${e}'`, t); + } + statImpl(e, t) { + const r = this.entries.get(t); + if (void 0 !== r) { + const e = this.libzip.struct.statS(); + if (-1 === this.libzip.statIndex(this.zip, r, 0, 0, e)) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + const A = this.stats.uid, + n = this.stats.gid, + o = this.libzip.struct.statSize(e) >>> 0, + i = 512, + s = Math.ceil(o / i), + a = 1e3 * (this.libzip.struct.statMtime(e) >>> 0), + c = a, + g = a, + l = a, + h = new Date(c), + p = new Date(g), + C = new Date(l), + f = new Date(a), + I = this.listings.has(t) + ? u.QB + : this.isSymbolicLink(r) + ? u.Zv + : u.Pe, + E = I === u.QB ? 493 : 420, + B = I | (511 & this.getUnixMode(r, E)); + return Object.assign(new d.StatEntry(), { + uid: A, + gid: n, + size: o, + blksize: i, + blocks: s, + atime: h, + birthtime: p, + ctime: C, + mtime: f, + atimeMs: c, + birthtimeMs: g, + ctimeMs: l, + mtimeMs: a, + mode: B, + }); + } + if (this.listings.has(t)) { + const e = this.stats.uid, + t = this.stats.gid, + r = 0, + A = 512, + n = 0, + o = this.stats.mtimeMs, + i = this.stats.mtimeMs, + s = this.stats.mtimeMs, + a = this.stats.mtimeMs, + c = new Date(o), + g = new Date(i), + l = new Date(s), + h = new Date(a), + p = 493 | u.QB; + return Object.assign(new d.StatEntry(), { + uid: e, + gid: t, + size: r, + blksize: A, + blocks: n, + atime: c, + birthtime: g, + ctime: l, + mtime: h, + atimeMs: o, + birthtimeMs: i, + ctimeMs: s, + mtimeMs: a, + mode: p, + }); + } + throw new Error('Unreachable'); + } + getUnixMode(e, t) { + if ( + -1 === + this.libzip.file.getExternalAttributes( + this.zip, + e, + 0, + 0, + this.libzip.uint08S, + this.libzip.uint32S + ) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + return this.libzip.getValue(this.libzip.uint08S, 'i8') >>> 0 !== + this.libzip.ZIP_OPSYS_UNIX + ? t + : this.libzip.getValue(this.libzip.uint32S, 'i32') >>> 16; + } + registerListing(e) { + let t = this.listings.get(e); + if (t) return t; + const r = this.registerListing(p.y1.dirname(e)); + return ( + (t = new Set()), + r.add(p.y1.basename(e)), + this.listings.set(e, t), + t + ); + } + registerEntry(e, t) { + this.registerListing(p.y1.dirname(e)).add(p.y1.basename(e)), + this.entries.set(e, t); + } + unregisterListing(e) { + this.listings.delete(e); + const t = this.listings.get(p.y1.dirname(e)); + null == t || t.delete(p.y1.basename(e)); + } + unregisterEntry(e) { + this.unregisterListing(e); + const t = this.entries.get(e); + this.entries.delete(e), + void 0 !== t && + (this.fileSources.delete(t), + this.isSymbolicLink(t) && this.symlinkCount--); + } + deleteEntry(e, t) { + this.unregisterEntry(e); + if (-1 === this.libzip.delete(this.zip, t)) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + } + resolveFilename(e, t, r = !0) { + if (!this.ready) throw h.Vw('archive closed, ' + e); + let A = p.y1.resolve(p.LZ.root, t); + if ('/' === A) return p.LZ.root; + const n = this.entries.get(A); + if (r && void 0 !== n) { + if (0 !== this.symlinkCount && this.isSymbolicLink(n)) { + const t = this.getFileSource(n).toString(); + return this.resolveFilename( + e, + p.y1.resolve(p.y1.dirname(A), t), + !0 + ); + } + return A; + } + for (;;) { + const t = this.resolveFilename(e, p.y1.dirname(A), !0), + n = this.listings.has(t), + o = this.entries.has(t); + if (!n && !o) throw h.z6(e); + if (!n) throw h.Ab(e); + if ( + ((A = p.y1.resolve(t, p.y1.basename(A))), + !r || 0 === this.symlinkCount) + ) + break; + const i = this.libzip.name.locate(this.zip, A.slice(1)); + if (-1 === i) break; + if (!this.isSymbolicLink(i)) break; + { + const e = this.getFileSource(i).toString(); + A = p.y1.resolve(p.y1.dirname(A), e); + } + } + return A; + } + allocateBuffer(e) { + Buffer.isBuffer(e) || (e = Buffer.from(e)); + const t = this.libzip.malloc(e.byteLength); + if (!t) throw new Error("Couldn't allocate enough memory"); + return ( + new Uint8Array(this.libzip.HEAPU8.buffer, t, e.byteLength).set(e), + { buffer: t, byteLength: e.byteLength } + ); + } + allocateUnattachedSource(e) { + const t = this.libzip.struct.errorS(), + { buffer: r, byteLength: A } = this.allocateBuffer(e), + n = this.libzip.source.fromUnattachedBuffer(r, A, 0, !0, t); + if (0 === n) throw (this.libzip.free(t), this.makeLibzipError(t)); + return n; + } + allocateSource(e) { + const { buffer: t, byteLength: r } = this.allocateBuffer(e), + A = this.libzip.source.fromBuffer(this.zip, t, r, 0, !0); + if (0 === A) + throw ( + (this.libzip.free(t), + this.makeLibzipError(this.libzip.getError(this.zip))) + ); + return A; + } + setFileSource(e, t) { + const r = Buffer.isBuffer(t) ? t : Buffer.from(t), + A = p.y1.relative(p.LZ.root, e), + n = this.allocateSource(t); + try { + const e = this.libzip.file.add( + this.zip, + A, + n, + this.libzip.ZIP_FL_OVERWRITE + ); + if (-1 === e) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + if ('mixed' !== this.level) { + let t; + t = + 0 === this.level + ? this.libzip.ZIP_CM_STORE + : this.libzip.ZIP_CM_DEFLATE; + if ( + -1 === + this.libzip.file.setCompression(this.zip, e, 0, t, this.level) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + } + return this.fileSources.set(e, r), e; + } catch (e) { + throw (this.libzip.source.free(n), e); + } + } + isSymbolicLink(e) { + if (0 === this.symlinkCount) return !1; + if ( + -1 === + this.libzip.file.getExternalAttributes( + this.zip, + e, + 0, + 0, + this.libzip.uint08S, + this.libzip.uint32S + ) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + if ( + this.libzip.getValue(this.libzip.uint08S, 'i8') >>> 0 !== + this.libzip.ZIP_OPSYS_UNIX + ) + return !1; + return ( + ((this.libzip.getValue(this.libzip.uint32S, 'i32') >>> 16) & + u.wK) === + u.Zv + ); + } + getFileSource(e, t = { asyncDecompress: !1 }) { + const r = this.fileSources.get(e); + if (void 0 !== r) return r; + const A = this.libzip.struct.statS(); + if (-1 === this.libzip.statIndex(this.zip, e, 0, 0, A)) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + const n = this.libzip.struct.statCompSize(A), + o = this.libzip.struct.statCompMethod(A), + i = this.libzip.malloc(n); + try { + const r = this.libzip.fopenIndex( + this.zip, + e, + 0, + this.libzip.ZIP_FL_COMPRESSED + ); + if (0 === r) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + try { + const A = this.libzip.fread(r, i, n, 0); + if (-1 === A) + throw this.makeLibzipError(this.libzip.file.getError(r)); + if (A < n) throw new Error('Incomplete read'); + if (A > n) throw new Error('Overread'); + const a = this.libzip.HEAPU8.subarray(i, i + n), + c = Buffer.from(a); + if (0 === o) return this.fileSources.set(e, c), c; + if (t.asyncDecompress) + return new Promise((t, r) => { + s().inflateRaw(c, (A, n) => { + A ? r(A) : (this.fileSources.set(e, n), t(n)); + }); + }); + { + const t = s().inflateRawSync(c); + return this.fileSources.set(e, t), t; + } + } finally { + this.libzip.fclose(r); + } + } finally { + this.libzip.free(i); + } + } + async chmodPromise(e, t) { + return this.chmodSync(e, t); + } + chmodSync(e, t) { + if (this.readOnly) throw h.YW(`chmod '${e}'`); + t &= 493; + const r = this.resolveFilename(`chmod '${e}'`, e, !1), + A = this.entries.get(r); + if (void 0 === A) + throw new Error( + `Assertion failed: The entry should have been registered (${r})` + ); + const n = (-512 & this.getUnixMode(A, 0 | u.Pe)) | t; + if ( + -1 === + this.libzip.file.setExternalAttributes( + this.zip, + A, + 0, + 0, + this.libzip.ZIP_OPSYS_UNIX, + n << 16 + ) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + } + async chownPromise(e, t, r) { + return this.chownSync(e, t, r); + } + chownSync(e, t, r) { + throw new Error('Unimplemented'); + } + async renamePromise(e, t) { + return this.renameSync(e, t); + } + renameSync(e, t) { + throw new Error('Unimplemented'); + } + async copyFilePromise(e, t, r) { + const { + indexSource: A, + indexDest: n, + resolvedDestP: o, + } = this.prepareCopyFile(e, t, r), + i = await this.getFileSource(A, { asyncDecompress: !0 }), + s = this.setFileSource(o, i); + s !== n && this.registerEntry(o, s); + } + copyFileSync(e, t, r = 0) { + const { + indexSource: A, + indexDest: n, + resolvedDestP: o, + } = this.prepareCopyFile(e, t, r), + i = this.getFileSource(A), + s = this.setFileSource(o, i); + s !== n && this.registerEntry(o, s); + } + prepareCopyFile(e, t, r = 0) { + if (this.readOnly) throw h.YW(`copyfile '${e} -> '${t}'`); + if (0 != (r & A.constants.COPYFILE_FICLONE_FORCE)) + throw h.bk( + 'unsupported clone operation', + `copyfile '${e}' -> ${t}'` + ); + const n = this.resolveFilename(`copyfile '${e} -> ${t}'`, e), + o = this.entries.get(n); + if (void 0 === o) throw h.hq(`copyfile '${e}' -> '${t}'`); + const i = this.resolveFilename(`copyfile '${e}' -> ${t}'`, t), + s = this.entries.get(i); + if ( + 0 != + (r & + (A.constants.COPYFILE_EXCL | + A.constants.COPYFILE_FICLONE_FORCE)) && + void 0 !== s + ) + throw h.cT(`copyfile '${e}' -> '${t}'`); + return { indexSource: o, resolvedDestP: i, indexDest: s }; + } + async appendFilePromise(e, t, r) { + if (this.readOnly) throw h.YW(`open '${e}'`); + return ( + void 0 === r + ? (r = { flag: 'a' }) + : 'string' == typeof r + ? (r = { flag: 'a', encoding: r }) + : void 0 === r.flag && (r = { flag: 'a', ...r }), + this.writeFilePromise(e, t, r) + ); + } + appendFileSync(e, t, r = {}) { + if (this.readOnly) throw h.YW(`open '${e}'`); + return ( + void 0 === r + ? (r = { flag: 'a' }) + : 'string' == typeof r + ? (r = { flag: 'a', encoding: r }) + : void 0 === r.flag && (r = { flag: 'a', ...r }), + this.writeFileSync(e, t, r) + ); + } + async writeFilePromise(e, t, r) { + const { + encoding: A, + index: n, + resolvedP: o, + } = this.prepareWriteFile(e, r); + void 0 !== n && + 'object' == typeof r && + r.flag && + r.flag.includes('a') && + (t = Buffer.concat([ + await this.getFileSource(n, { asyncDecompress: !0 }), + Buffer.from(t), + ])), + null !== A && (t = t.toString(A)); + const i = this.setFileSource(o, t); + i !== n && this.registerEntry(o, i); + } + writeFileSync(e, t, r) { + const { + encoding: A, + index: n, + resolvedP: o, + } = this.prepareWriteFile(e, r); + void 0 !== n && + 'object' == typeof r && + r.flag && + r.flag.includes('a') && + (t = Buffer.concat([this.getFileSource(n), Buffer.from(t)])), + null !== A && (t = t.toString(A)); + const i = this.setFileSource(o, t); + i !== n && this.registerEntry(o, i); + } + prepareWriteFile(e, t) { + if ('string' != typeof e) throw h.Ch('read'); + if (this.readOnly) throw h.YW(`open '${e}'`); + const r = this.resolveFilename(`open '${e}'`, e); + if (this.listings.has(r)) throw h.GA(`open '${e}'`); + let A = null; + 'string' == typeof t + ? (A = t) + : 'object' == typeof t && t.encoding && (A = t.encoding); + return { encoding: A, resolvedP: r, index: this.entries.get(r) }; + } + async unlinkPromise(e) { + return this.unlinkSync(e); + } + unlinkSync(e) { + if (this.readOnly) throw h.YW(`unlink '${e}'`); + const t = this.resolveFilename(`unlink '${e}'`, e); + if (this.listings.has(t)) throw h.GA(`unlink '${e}'`); + const r = this.entries.get(t); + if (void 0 === r) throw h.hq(`unlink '${e}'`); + this.deleteEntry(t, r); + } + async utimesPromise(e, t, r) { + return this.utimesSync(e, t, r); + } + utimesSync(e, t, r) { + if (this.readOnly) throw h.YW(`utimes '${e}'`); + const A = this.resolveFilename(`utimes '${e}'`, e); + this.utimesImpl(A, r); + } + async lutimesPromise(e, t, r) { + return this.lutimesSync(e, t, r); + } + lutimesSync(e, t, r) { + if (this.readOnly) throw h.YW(`lutimes '${e}'`); + const A = this.resolveFilename(`utimes '${e}'`, e, !1); + this.utimesImpl(A, r); + } + utimesImpl(e, t) { + this.listings.has(e) && + (this.entries.has(e) || this.hydrateDirectory(e)); + const r = this.entries.get(e); + if (void 0 === r) throw new Error('Unreachable'); + if ( + -1 === + this.libzip.file.setMtime( + this.zip, + r, + 0, + (function (e) { + if ('string' == typeof e && String(+e) === e) return +e; + if (Number.isFinite(e)) return e < 0 ? Date.now() / 1e3 : e; + if ((0, o.isDate)(e)) return e.getTime() / 1e3; + throw new Error('Invalid time'); + })(t), + 0 + ) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + } + async mkdirPromise(e, t) { + return this.mkdirSync(e, t); + } + mkdirSync(e, { mode: t = 493, recursive: r = !1 } = {}) { + if (r) return void this.mkdirpSync(e, { chmod: t }); + if (this.readOnly) throw h.YW(`mkdir '${e}'`); + const A = this.resolveFilename(`mkdir '${e}'`, e); + if (this.entries.has(A) || this.listings.has(A)) + throw h.cT(`mkdir '${e}'`); + this.hydrateDirectory(A), this.chmodSync(A, t); + } + async rmdirPromise(e, t) { + return this.rmdirSync(e, t); + } + rmdirSync(e, { recursive: t = !1 } = {}) { + if (this.readOnly) throw h.YW(`rmdir '${e}'`); + if (t) return void this.removeSync(e); + const r = this.resolveFilename(`rmdir '${e}'`, e), + A = this.listings.get(r); + if (!A) throw h.Ab(`rmdir '${e}'`); + if (A.size > 0) throw h.re(`rmdir '${e}'`); + const n = this.entries.get(r); + if (void 0 === n) throw h.hq(`rmdir '${e}'`); + this.deleteEntry(e, n); + } + hydrateDirectory(e) { + const t = this.libzip.dir.add( + this.zip, + p.y1.relative(p.LZ.root, e) + ); + if (-1 === t) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + return this.registerListing(e), this.registerEntry(e, t), t; + } + async linkPromise(e, t) { + return this.linkSync(e, t); + } + linkSync(e, t) { + throw h.Hs(`link '${e}' -> '${t}'`); + } + async symlinkPromise(e, t) { + return this.symlinkSync(e, t); + } + symlinkSync(e, t) { + if (this.readOnly) throw h.YW(`symlink '${e}' -> '${t}'`); + const r = this.resolveFilename(`symlink '${e}' -> '${t}'`, t); + if (this.listings.has(r)) throw h.GA(`symlink '${e}' -> '${t}'`); + if (this.entries.has(r)) throw h.cT(`symlink '${e}' -> '${t}'`); + const A = this.setFileSource(r, e); + this.registerEntry(r, A); + if ( + -1 === + this.libzip.file.setExternalAttributes( + this.zip, + A, + 0, + 0, + this.libzip.ZIP_OPSYS_UNIX, + (511 | u.Zv) << 16 + ) + ) + throw this.makeLibzipError(this.libzip.getError(this.zip)); + this.symlinkCount += 1; + } + async readFilePromise(e, t) { + 'object' == typeof t && (t = t ? t.encoding : void 0); + const r = await this.readFileBuffer(e, { asyncDecompress: !0 }); + return t ? r.toString(t) : r; + } + readFileSync(e, t) { + 'object' == typeof t && (t = t ? t.encoding : void 0); + const r = this.readFileBuffer(e); + return t ? r.toString(t) : r; + } + readFileBuffer(e, t = { asyncDecompress: !1 }) { + if ('string' != typeof e) throw h.Ch('read'); + const r = this.resolveFilename(`open '${e}'`, e); + if (!this.entries.has(r) && !this.listings.has(r)) + throw h.z6(`open '${e}'`); + if ('/' === e[e.length - 1] && !this.listings.has(r)) + throw h.Ab(`open '${e}'`); + if (this.listings.has(r)) throw h.GA('read'); + const A = this.entries.get(r); + if (void 0 === A) throw new Error('Unreachable'); + return this.getFileSource(A, t); + } + async readdirPromise(e, { withFileTypes: t } = {}) { + return this.readdirSync(e, { withFileTypes: t }); + } + readdirSync(e, { withFileTypes: t } = {}) { + const r = this.resolveFilename(`scandir '${e}'`, e); + if (!this.entries.has(r) && !this.listings.has(r)) + throw h.z6(`scandir '${e}'`); + const A = this.listings.get(r); + if (!A) throw h.Ab(`scandir '${e}'`); + const n = [...A]; + return t + ? n.map((t) => + Object.assign(this.statImpl('lstat', p.y1.join(e, t)), { + name: t, + }) + ) + : n; + } + async readlinkPromise(e) { + const t = this.prepareReadlink(e); + return ( + await this.getFileSource(t, { asyncDecompress: !0 }) + ).toString(); + } + readlinkSync(e) { + const t = this.prepareReadlink(e); + return this.getFileSource(t).toString(); + } + prepareReadlink(e) { + const t = this.resolveFilename(`readlink '${e}'`, e, !1); + if (!this.entries.has(t) && !this.listings.has(t)) + throw h.z6(`readlink '${e}'`); + if ('/' === e[e.length - 1] && !this.listings.has(t)) + throw h.Ab(`open '${e}'`); + if (this.listings.has(t)) throw h.hq(`readlink '${e}'`); + const r = this.entries.get(t); + if (void 0 === r) throw new Error('Unreachable'); + if (!this.isSymbolicLink(r)) throw h.hq(`readlink '${e}'`); + return r; + } + async truncatePromise(e, t = 0) { + const r = this.resolveFilename(`open '${e}'`, e), + A = this.entries.get(r); + if (void 0 === A) throw h.hq(`open '${e}'`); + const n = await this.getFileSource(A, { asyncDecompress: !0 }), + o = Buffer.alloc(t, 0); + return n.copy(o), await this.writeFilePromise(e, o); + } + truncateSync(e, t = 0) { + const r = this.resolveFilename(`open '${e}'`, e), + A = this.entries.get(r); + if (void 0 === A) throw h.hq(`open '${e}'`); + const n = this.getFileSource(A), + o = Buffer.alloc(t, 0); + return n.copy(o), this.writeFileSync(e, o); + } + watch(e, t, r) { + let A; + switch (typeof t) { + case 'function': + case 'string': + case 'undefined': + A = !0; + break; + default: + ({ persistent: A = !0 } = t); + } + if (!A) return { on: () => {}, close: () => {} }; + const n = setInterval(() => {}, 864e5); + return { + on: () => {}, + close: () => { + clearInterval(n); + }, + }; + } + watchFile(e, t, r) { + const A = this.resolveFilename(`open '${e}'`, e); + return (0, l._x)(this, A, t, r); + } + unwatchFile(e, t) { + const r = this.resolveFilename(`open '${e}'`, e); + return (0, l.nd)(this, r, t); + } + } + }, + 53660: (e, t, r) => { + 'use strict'; + r.d(t, { A: () => l }); + var A = r(35747), + n = r(5944), + o = r(78420), + i = r(90739), + s = r(38783), + a = r(46009); + const c = 2147483648, + g = /.*?(? await this.baseFs.openPromise(e, t, r), + async (e, { subPath: A }) => + this.remapFd(e, await e.openPromise(A, t, r)) + ); + } + openSync(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.openSync(e, t, r), + (e, { subPath: A }) => this.remapFd(e, e.openSync(A, t, r)) + ); + } + async opendirPromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.opendirPromise(e, t), + async (e, { subPath: r }) => await e.opendirPromise(r, t), + { requireSubpath: !1 } + ); + } + opendirSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.opendirSync(e, t), + (e, { subPath: r }) => e.opendirSync(r, t), + { requireSubpath: !1 } + ); + } + async readPromise(e, t, r, A, n) { + if (0 == (e & c)) + return await this.baseFs.readPromise(e, t, r, A, n); + const o = this.fdMap.get(e); + if (void 0 === o) + throw Object.assign( + new Error('EBADF: bad file descriptor, read'), + { code: 'EBADF' } + ); + const [i, s] = o; + return await i.readPromise(s, t, r, A, n); + } + readSync(e, t, r, A, n) { + if (0 == (e & c)) return this.baseFs.readSync(e, t, r, A, n); + const o = this.fdMap.get(e); + if (void 0 === o) + throw Object.assign( + new Error('EBADF: bad file descriptor, read'), + { code: 'EBADF' } + ); + const [i, s] = o; + return i.readSync(s, t, r, A, n); + } + async writePromise(e, t, r, A, n) { + if (0 == (e & c)) + return 'string' == typeof t + ? await this.baseFs.writePromise(e, t, r) + : await this.baseFs.writePromise(e, t, r, A, n); + const o = this.fdMap.get(e); + if (void 0 === o) + throw Object.assign( + new Error('EBADF: bad file descriptor, write'), + { code: 'EBADF' } + ); + const [i, s] = o; + return 'string' == typeof t + ? await i.writePromise(s, t, r) + : await i.writePromise(s, t, r, A, n); + } + writeSync(e, t, r, A, n) { + if (0 == (e & c)) + return 'string' == typeof t + ? this.baseFs.writeSync(e, t, r) + : this.baseFs.writeSync(e, t, r, A, n); + const o = this.fdMap.get(e); + if (void 0 === o) + throw Object.assign( + new Error('EBADF: bad file descriptor, write'), + { code: 'EBADF' } + ); + const [i, s] = o; + return 'string' == typeof t + ? i.writeSync(s, t, r) + : i.writeSync(s, t, r, A, n); + } + async closePromise(e) { + if (0 == (e & c)) return await this.baseFs.closePromise(e); + const t = this.fdMap.get(e); + if (void 0 === t) + throw Object.assign( + new Error('EBADF: bad file descriptor, close'), + { code: 'EBADF' } + ); + this.fdMap.delete(e); + const [r, A] = t; + return await r.closePromise(A); + } + closeSync(e) { + if (0 == (e & c)) return this.baseFs.closeSync(e); + const t = this.fdMap.get(e); + if (void 0 === t) + throw Object.assign( + new Error('EBADF: bad file descriptor, close'), + { code: 'EBADF' } + ); + this.fdMap.delete(e); + const [r, A] = t; + return r.closeSync(A); + } + createReadStream(e, t) { + return null === e + ? this.baseFs.createReadStream(e, t) + : this.makeCallSync( + e, + () => this.baseFs.createReadStream(e, t), + (e, { subPath: r }) => e.createReadStream(r, t) + ); + } + createWriteStream(e, t) { + return null === e + ? this.baseFs.createWriteStream(e, t) + : this.makeCallSync( + e, + () => this.baseFs.createWriteStream(e, t), + (e, { subPath: r }) => e.createWriteStream(r, t) + ); + } + async realpathPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.realpathPromise(e), + async (e, { archivePath: t, subPath: r }) => { + let A = this.realPaths.get(t); + return ( + void 0 === A && + ((A = await this.baseFs.realpathPromise(t)), + this.realPaths.set(t, A)), + this.pathUtils.join( + A, + this.pathUtils.relative( + a.LZ.root, + await e.realpathPromise(r) + ) + ) + ); + } + ); + } + realpathSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.realpathSync(e), + (e, { archivePath: t, subPath: r }) => { + let A = this.realPaths.get(t); + return ( + void 0 === A && + ((A = this.baseFs.realpathSync(t)), + this.realPaths.set(t, A)), + this.pathUtils.join( + A, + this.pathUtils.relative(a.LZ.root, e.realpathSync(r)) + ) + ); + } + ); + } + async existsPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.existsPromise(e), + async (e, { subPath: t }) => await e.existsPromise(t) + ); + } + existsSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.existsSync(e), + (e, { subPath: t }) => e.existsSync(t) + ); + } + async accessPromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.accessPromise(e, t), + async (e, { subPath: r }) => await e.accessPromise(r, t) + ); + } + accessSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.accessSync(e, t), + (e, { subPath: r }) => e.accessSync(r, t) + ); + } + async statPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.statPromise(e), + async (e, { subPath: t }) => await e.statPromise(t) + ); + } + statSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.statSync(e), + (e, { subPath: t }) => e.statSync(t) + ); + } + async lstatPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.lstatPromise(e), + async (e, { subPath: t }) => await e.lstatPromise(t) + ); + } + lstatSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.lstatSync(e), + (e, { subPath: t }) => e.lstatSync(t) + ); + } + async chmodPromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.chmodPromise(e, t), + async (e, { subPath: r }) => await e.chmodPromise(r, t) + ); + } + chmodSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.chmodSync(e, t), + (e, { subPath: r }) => e.chmodSync(r, t) + ); + } + async chownPromise(e, t, r) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.chownPromise(e, t, r), + async (e, { subPath: A }) => await e.chownPromise(A, t, r) + ); + } + chownSync(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.chownSync(e, t, r), + (e, { subPath: A }) => e.chownSync(A, t, r) + ); + } + async renamePromise(e, t) { + return await this.makeCallPromise( + e, + async () => + await this.makeCallPromise( + t, + async () => await this.baseFs.renamePromise(e, t), + async () => { + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + } + ), + async (e, { subPath: r }) => + await this.makeCallPromise( + t, + async () => { + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + }, + async (t, { subPath: A }) => { + if (e !== t) + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + return await e.renamePromise(r, A); + } + ) + ); + } + renameSync(e, t) { + return this.makeCallSync( + e, + () => + this.makeCallSync( + t, + () => this.baseFs.renameSync(e, t), + async () => { + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + } + ), + (e, { subPath: r }) => + this.makeCallSync( + t, + () => { + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + }, + (t, { subPath: A }) => { + if (e !== t) + throw Object.assign( + new Error('EEXDEV: cross-device link not permitted'), + { code: 'EEXDEV' } + ); + return e.renameSync(r, A); + } + ) + ); + } + async copyFilePromise(e, t, r = 0) { + const n = async (e, t, n, o) => { + if (0 != (r & A.constants.COPYFILE_FICLONE_FORCE)) + throw Object.assign( + new Error( + `EXDEV: cross-device clone not permitted, copyfile '${t}' -> ${o}'` + ), + { code: 'EXDEV' } + ); + if ( + r & A.constants.COPYFILE_EXCL && + (await this.existsPromise(t)) + ) + throw Object.assign( + new Error( + `EEXIST: file already exists, copyfile '${t}' -> '${o}'` + ), + { code: 'EEXIST' } + ); + let i; + try { + i = await e.readFilePromise(t); + } catch (e) { + throw Object.assign( + new Error( + `EINVAL: invalid argument, copyfile '${t}' -> '${o}'` + ), + { code: 'EINVAL' } + ); + } + await n.writeFilePromise(o, i); + }; + return await this.makeCallPromise( + e, + async () => + await this.makeCallPromise( + t, + async () => await this.baseFs.copyFilePromise(e, t, r), + async (t, { subPath: r }) => await n(this.baseFs, e, t, r) + ), + async (e, { subPath: A }) => + await this.makeCallPromise( + t, + async () => await n(e, A, this.baseFs, t), + async (t, { subPath: o }) => + e !== t + ? await n(e, A, t, o) + : await e.copyFilePromise(A, o, r) + ) + ); + } + copyFileSync(e, t, r = 0) { + const n = (e, t, n, o) => { + if (0 != (r & A.constants.COPYFILE_FICLONE_FORCE)) + throw Object.assign( + new Error( + `EXDEV: cross-device clone not permitted, copyfile '${t}' -> ${o}'` + ), + { code: 'EXDEV' } + ); + if (r & A.constants.COPYFILE_EXCL && this.existsSync(t)) + throw Object.assign( + new Error( + `EEXIST: file already exists, copyfile '${t}' -> '${o}'` + ), + { code: 'EEXIST' } + ); + let i; + try { + i = e.readFileSync(t); + } catch (e) { + throw Object.assign( + new Error( + `EINVAL: invalid argument, copyfile '${t}' -> '${o}'` + ), + { code: 'EINVAL' } + ); + } + n.writeFileSync(o, i); + }; + return this.makeCallSync( + e, + () => + this.makeCallSync( + t, + () => this.baseFs.copyFileSync(e, t, r), + (t, { subPath: r }) => n(this.baseFs, e, t, r) + ), + (e, { subPath: A }) => + this.makeCallSync( + t, + () => n(e, A, this.baseFs, t), + (t, { subPath: o }) => + e !== t ? n(e, A, t, o) : e.copyFileSync(A, o, r) + ) + ); + } + async appendFilePromise(e, t, r) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.appendFilePromise(e, t, r), + async (e, { subPath: A }) => await e.appendFilePromise(A, t, r) + ); + } + appendFileSync(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.appendFileSync(e, t, r), + (e, { subPath: A }) => e.appendFileSync(A, t, r) + ); + } + async writeFilePromise(e, t, r) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.writeFilePromise(e, t, r), + async (e, { subPath: A }) => await e.writeFilePromise(A, t, r) + ); + } + writeFileSync(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.writeFileSync(e, t, r), + (e, { subPath: A }) => e.writeFileSync(A, t, r) + ); + } + async unlinkPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.unlinkPromise(e), + async (e, { subPath: t }) => await e.unlinkPromise(t) + ); + } + unlinkSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.unlinkSync(e), + (e, { subPath: t }) => e.unlinkSync(t) + ); + } + async utimesPromise(e, t, r) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.utimesPromise(e, t, r), + async (e, { subPath: A }) => await e.utimesPromise(A, t, r) + ); + } + utimesSync(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.utimesSync(e, t, r), + (e, { subPath: A }) => e.utimesSync(A, t, r) + ); + } + async mkdirPromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.mkdirPromise(e, t), + async (e, { subPath: r }) => await e.mkdirPromise(r, t) + ); + } + mkdirSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.mkdirSync(e, t), + (e, { subPath: r }) => e.mkdirSync(r, t) + ); + } + async rmdirPromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.rmdirPromise(e, t), + async (e, { subPath: r }) => await e.rmdirPromise(r, t) + ); + } + rmdirSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.rmdirSync(e, t), + (e, { subPath: r }) => e.rmdirSync(r, t) + ); + } + async linkPromise(e, t) { + return await this.makeCallPromise( + t, + async () => await this.baseFs.linkPromise(e, t), + async (t, { subPath: r }) => await t.linkPromise(e, r) + ); + } + linkSync(e, t) { + return this.makeCallSync( + t, + () => this.baseFs.linkSync(e, t), + (t, { subPath: r }) => t.linkSync(e, r) + ); + } + async symlinkPromise(e, t, r) { + return await this.makeCallPromise( + t, + async () => await this.baseFs.symlinkPromise(e, t, r), + async (t, { subPath: r }) => await t.symlinkPromise(e, r) + ); + } + symlinkSync(e, t, r) { + return this.makeCallSync( + t, + () => this.baseFs.symlinkSync(e, t, r), + (t, { subPath: r }) => t.symlinkSync(e, r) + ); + } + async readFilePromise(e, t) { + return this.makeCallPromise( + e, + async () => { + switch (t) { + case 'utf8': + default: + return await this.baseFs.readFilePromise(e, t); + } + }, + async (e, { subPath: r }) => await e.readFilePromise(r, t) + ); + } + readFileSync(e, t) { + return this.makeCallSync( + e, + () => { + switch (t) { + case 'utf8': + default: + return this.baseFs.readFileSync(e, t); + } + }, + (e, { subPath: r }) => e.readFileSync(r, t) + ); + } + async readdirPromise(e, { withFileTypes: t } = {}) { + return await this.makeCallPromise( + e, + async () => + await this.baseFs.readdirPromise(e, { withFileTypes: t }), + async (e, { subPath: r }) => + await e.readdirPromise(r, { withFileTypes: t }), + { requireSubpath: !1 } + ); + } + readdirSync(e, { withFileTypes: t } = {}) { + return this.makeCallSync( + e, + () => this.baseFs.readdirSync(e, { withFileTypes: t }), + (e, { subPath: r }) => e.readdirSync(r, { withFileTypes: t }), + { requireSubpath: !1 } + ); + } + async readlinkPromise(e) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.readlinkPromise(e), + async (e, { subPath: t }) => await e.readlinkPromise(t) + ); + } + readlinkSync(e) { + return this.makeCallSync( + e, + () => this.baseFs.readlinkSync(e), + (e, { subPath: t }) => e.readlinkSync(t) + ); + } + async truncatePromise(e, t) { + return await this.makeCallPromise( + e, + async () => await this.baseFs.truncatePromise(e, t), + async (e, { subPath: r }) => await e.truncatePromise(r, t) + ); + } + truncateSync(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.truncateSync(e, t), + (e, { subPath: r }) => e.truncateSync(r, t) + ); + } + watch(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.watch(e, t, r), + (e, { subPath: A }) => e.watch(A, t, r) + ); + } + watchFile(e, t, r) { + return this.makeCallSync( + e, + () => this.baseFs.watchFile(e, t, r), + () => (0, s._x)(this, e, t, r) + ); + } + unwatchFile(e, t) { + return this.makeCallSync( + e, + () => this.baseFs.unwatchFile(e, t), + () => (0, s.nd)(this, e, t) + ); + } + async makeCallPromise(e, t, r, { requireSubpath: A = !0 } = {}) { + if ('string' != typeof e) return await t(); + const n = this.resolve(e), + o = this.findZip(n); + return o + ? A && '/' === o.subPath + ? await t() + : await this.getZipPromise( + o.archivePath, + async (e) => await r(e, o) + ) + : await t(); + } + makeCallSync(e, t, r, { requireSubpath: A = !0 } = {}) { + if ('string' != typeof e) return t(); + const n = this.resolve(e), + o = this.findZip(n); + return o + ? A && '/' === o.subPath + ? t() + : this.getZipSync(o.archivePath, (e) => r(e, o)) + : t(); + } + findZip(e) { + if (this.filter && !this.filter.test(e)) return null; + let t = ''; + for (;;) { + const r = g.exec(e.substr(t.length)); + if (!r) return null; + if ( + ((t = this.pathUtils.join(t, r[0])), !1 === this.isZip.has(t)) + ) { + if (this.notZip.has(t)) continue; + try { + if (!this.baseFs.lstatSync(t).isFile()) { + this.notZip.add(t); + continue; + } + } catch (e) { + return null; + } + this.isZip.add(t); + } + return { + archivePath: t, + subPath: this.pathUtils.join(a.LZ.root, e.substr(t.length)), + }; + } + } + limitOpenFiles(e) { + if (null === this.zipInstances) return; + const t = Date.now(); + let r = t + this.maxAge, + A = null === e ? 0 : this.zipInstances.size - e; + for (const [ + n, + { zipFs: o, expiresAt: i, refCount: s }, + ] of this.zipInstances.entries()) + if (0 === s && !o.hasOpenFileHandles()) + if (t >= i) + o.saveAndClose(), this.zipInstances.delete(n), (A -= 1); + else { + if (null === e || A <= 0) { + r = i; + break; + } + o.saveAndClose(), this.zipInstances.delete(n), (A -= 1); + } + null === this.limitOpenFilesTimeout && + ((null === e && this.zipInstances.size > 0) || null !== e) && + (this.limitOpenFilesTimeout = setTimeout(() => { + (this.limitOpenFilesTimeout = null), this.limitOpenFiles(null); + }, r - t).unref()); + } + async getZipPromise(e, t) { + const r = async () => ({ + baseFs: this.baseFs, + libzip: this.libzip, + readOnly: this.readOnlyArchives, + stats: await this.baseFs.statPromise(e), + }); + if (this.zipInstances) { + let A = this.zipInstances.get(e); + if (!A) { + const t = await r(); + (A = this.zipInstances.get(e)), + A || + (A = { zipFs: new i.d(e, t), expiresAt: 0, refCount: 0 }); + } + this.zipInstances.delete(e), + this.limitOpenFiles(this.maxOpenFiles - 1), + this.zipInstances.set(e, A), + (A.expiresAt = Date.now() + this.maxAge), + (A.refCount += 1); + try { + return await t(A.zipFs); + } finally { + A.refCount -= 1; + } + } else { + const A = new i.d(e, await r()); + try { + return await t(A); + } finally { + A.saveAndClose(); + } + } + } + getZipSync(e, t) { + const r = () => ({ + baseFs: this.baseFs, + libzip: this.libzip, + readOnly: this.readOnlyArchives, + stats: this.baseFs.statSync(e), + }); + if (this.zipInstances) { + let A = this.zipInstances.get(e); + return ( + A || + (A = { zipFs: new i.d(e, r()), expiresAt: 0, refCount: 0 }), + this.zipInstances.delete(e), + this.limitOpenFiles(this.maxOpenFiles - 1), + this.zipInstances.set(e, A), + (A.expiresAt = Date.now() + this.maxAge), + t(A.zipFs) + ); + } + { + const A = new i.d(e, r()); + try { + return t(A); + } finally { + A.saveAndClose(); + } + } + } + } + }, + 19697: (e, t, r) => { + 'use strict'; + r.d(t, { a: () => o }); + var A = r(26984); + class n { + constructor(e, t, r = {}) { + (this.path = e), + (this.nextDirent = t), + (this.opts = r), + (this.closed = !1); + } + throwIfClosed() { + if (this.closed) throw A.Xh(); + } + async *[Symbol.asyncIterator]() { + try { + let e; + for (; null !== (e = await this.read()); ) yield e; + } finally { + await this.close(); + } + } + read(e) { + const t = this.readSync(); + return void 0 !== e ? e(null, t) : Promise.resolve(t); + } + readSync() { + return this.throwIfClosed(), this.nextDirent(); + } + close(e) { + return this.closeSync(), void 0 !== e ? e(null) : Promise.resolve(); + } + closeSync() { + var e, t; + this.throwIfClosed(), + null === (t = (e = this.opts).onClose) || + void 0 === t || + t.call(e), + (this.closed = !0); + } + } + function o(e, t, r, A) { + return new n( + t, + () => { + const A = r.shift(); + return void 0 === A + ? null + : Object.assign(e.statSync(e.pathUtils.join(t, A)), { + name: A, + }); + }, + A + ); + } + }, + 38783: (e, t, r) => { + 'use strict'; + r.d(t, { L: () => u, nd: () => l, _x: () => g }); + var A, + n, + o = r(28614), + i = r(65760); + function s(e, t) { + if (e !== t) + throw new Error( + `Invalid StatWatcher status: expected '${t}', got '${e}'` + ); + } + !(function (e) { + (e.Change = 'change'), (e.Stop = 'stop'); + })(A || (A = {})), + (function (e) { + (e.Ready = 'ready'), + (e.Running = 'running'), + (e.Stopped = 'stopped'); + })(n || (n = {})); + class a extends o.EventEmitter { + constructor(e, t, { bigint: r = !1 } = {}) { + super(), + (this.status = n.Ready), + (this.changeListeners = new Map()), + (this.startTimeout = null), + (this.fakeFs = e), + (this.path = t), + (this.bigint = r), + (this.lastStats = this.stat()); + } + static create(e, t, r) { + const A = new a(e, t, r); + return A.start(), A; + } + start() { + s(this.status, n.Ready), + (this.status = n.Running), + (this.startTimeout = setTimeout(() => { + (this.startTimeout = null), + this.fakeFs.existsSync(this.path) || + this.emit(A.Change, this.lastStats, this.lastStats); + }, 3)); + } + stop() { + s(this.status, n.Running), + (this.status = n.Stopped), + null !== this.startTimeout && + (clearTimeout(this.startTimeout), (this.startTimeout = null)), + this.emit(A.Stop); + } + stat() { + try { + return this.fakeFs.statSync(this.path); + } catch (e) { + if ('ENOENT' === e.code) return i.makeEmptyStats(); + throw e; + } + } + makeInterval(e) { + const t = setInterval(() => { + const e = this.stat(), + t = this.lastStats; + i.areStatsEqual(e, t) || + ((this.lastStats = e), this.emit(A.Change, e, t)); + }, e.interval); + return e.persistent ? t : t.unref(); + } + registerChangeListener(e, t) { + this.addListener(A.Change, e), + this.changeListeners.set(e, this.makeInterval(t)); + } + unregisterChangeListener(e) { + this.removeListener(A.Change, e); + const t = this.changeListeners.get(e); + void 0 !== t && clearInterval(t), this.changeListeners.delete(e); + } + unregisterAllChangeListeners() { + for (const e of this.changeListeners.keys()) + this.unregisterChangeListener(e); + } + hasChangeListeners() { + return this.changeListeners.size > 0; + } + ref() { + for (const e of this.changeListeners.values()) e.ref(); + return this; + } + unref() { + for (const e of this.changeListeners.values()) e.unref(); + return this; + } + } + const c = new WeakMap(); + function g(e, t, r, A) { + let n, o, i, s; + switch (typeof r) { + case 'function': + (n = !1), (o = !0), (i = 5007), (s = r); + break; + default: + ({ bigint: n = !1, persistent: o = !0, interval: i = 5007 } = r), + (s = A); + } + let g = c.get(e); + void 0 === g && c.set(e, (g = new Map())); + let l = g.get(t); + return ( + void 0 === l && ((l = a.create(e, t, { bigint: n })), g.set(t, l)), + l.registerChangeListener(s, { persistent: o, interval: i }), + l + ); + } + function l(e, t, r) { + const A = c.get(e); + if (void 0 === A) return; + const n = A.get(t); + void 0 !== n && + (void 0 === r + ? n.unregisterAllChangeListeners() + : n.unregisterChangeListener(r), + n.hasChangeListeners() || (n.stop(), A.delete(t))); + } + function u(e) { + const t = c.get(e); + if (void 0 !== t) for (const r of t.keys()) l(e, r); + } + }, + 22004: (e, t, r) => { + 'use strict'; + r.d(t, { wK: () => A, QB: () => n, Pe: () => o, Zv: () => i }); + const A = 61440, + n = 16384, + o = 32768, + i = 40960; + }, + 26984: (e, t, r) => { + 'use strict'; + function A(e, t) { + return Object.assign(new Error(`${e}: ${t}`), { code: e }); + } + function n(e) { + return A('EBUSY', e); + } + function o(e, t) { + return A('ENOSYS', `${e}, ${t}`); + } + function i(e) { + return A('EINVAL', 'invalid argument, ' + e); + } + function s(e) { + return A('EBADF', 'bad file descriptor, ' + e); + } + function a(e) { + return A('ENOENT', 'no such file or directory, ' + e); + } + function c(e) { + return A('ENOTDIR', 'not a directory, ' + e); + } + function g(e) { + return A('EISDIR', 'illegal operation on a directory, ' + e); + } + function l(e) { + return A('EEXIST', 'file already exists, ' + e); + } + function u(e) { + return A('EROFS', 'read-only filesystem, ' + e); + } + function h(e) { + return A('ENOTEMPTY', 'directory not empty, ' + e); + } + function p(e) { + return A('EOPNOTSUPP', 'operation not supported, ' + e); + } + function d() { + return A('ERR_DIR_CLOSED', 'Directory handle was closed'); + } + r.d(t, { + Vw: () => n, + bk: () => o, + hq: () => i, + Ch: () => s, + z6: () => a, + Ab: () => c, + GA: () => g, + cT: () => l, + YW: () => u, + re: () => h, + Hs: () => p, + Xh: () => d, + Yn: () => C, + }); + class C extends Error { + constructor(e, t) { + super(e), (this.name = 'Libzip Error'), (this.code = t); + } + } + }, + 43896: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + AliasFS: () => u.K, + CwdFS: () => h.M, + DEFAULT_COMPRESSION_LEVEL: () => l.k, + FakeFS: () => g.uY, + Filename: () => s.QS, + JailFS: () => p.n, + LazyFS: () => d.v, + NoFS: () => f, + NodeFS: () => i.S, + PortablePath: () => s.LZ, + PosixFS: () => I.i, + ProxiedFS: () => E.p, + VirtualFS: () => B.p, + ZipFS: () => l.d, + ZipOpenFS: () => y.A, + extendFs: () => Q, + normalizeLineEndings: () => g.qH, + npath: () => s.cS, + opendir: () => c.a, + patchFs: () => w, + ppath: () => s.y1, + statUtils: () => a, + toFilename: () => s.Zu, + xfs: () => S, + }); + var A = r(12087), + n = r.n(A), + o = r(31669), + i = r(78420), + s = r(46009), + a = r(65760), + c = r(19697), + g = r(5944), + l = r(90739), + u = r(14626), + h = r(75448), + p = r(10489), + d = r(15037); + const C = () => + Object.assign(new Error('ENOSYS: unsupported filesystem access'), { + code: 'ENOSYS', + }); + class f extends g.uY { + constructor() { + super(s.y1); + } + getExtractHint() { + throw C(); + } + getRealPath() { + throw C(); + } + resolve() { + throw C(); + } + async openPromise() { + throw C(); + } + openSync() { + throw C(); + } + async opendirPromise() { + throw C(); + } + opendirSync() { + throw C(); + } + async readPromise() { + throw C(); + } + readSync() { + throw C(); + } + async writePromise() { + throw C(); + } + writeSync() { + throw C(); + } + async closePromise() { + throw C(); + } + closeSync() { + throw C(); + } + createWriteStream() { + throw C(); + } + createReadStream() { + throw C(); + } + async realpathPromise() { + throw C(); + } + realpathSync() { + throw C(); + } + async readdirPromise() { + throw C(); + } + readdirSync() { + throw C(); + } + async existsPromise(e) { + throw C(); + } + existsSync(e) { + throw C(); + } + async accessPromise() { + throw C(); + } + accessSync() { + throw C(); + } + async statPromise() { + throw C(); + } + statSync() { + throw C(); + } + async lstatPromise(e) { + throw C(); + } + lstatSync(e) { + throw C(); + } + async chmodPromise() { + throw C(); + } + chmodSync() { + throw C(); + } + async chownPromise() { + throw C(); + } + chownSync() { + throw C(); + } + async mkdirPromise() { + throw C(); + } + mkdirSync() { + throw C(); + } + async rmdirPromise() { + throw C(); + } + rmdirSync() { + throw C(); + } + async linkPromise() { + throw C(); + } + linkSync() { + throw C(); + } + async symlinkPromise() { + throw C(); + } + symlinkSync() { + throw C(); + } + async renamePromise() { + throw C(); + } + renameSync() { + throw C(); + } + async copyFilePromise() { + throw C(); + } + copyFileSync() { + throw C(); + } + async appendFilePromise() { + throw C(); + } + appendFileSync() { + throw C(); + } + async writeFilePromise() { + throw C(); + } + writeFileSync() { + throw C(); + } + async unlinkPromise() { + throw C(); + } + unlinkSync() { + throw C(); + } + async utimesPromise() { + throw C(); + } + utimesSync() { + throw C(); + } + async readFilePromise() { + throw C(); + } + readFileSync() { + throw C(); + } + async readlinkPromise() { + throw C(); + } + readlinkSync() { + throw C(); + } + async truncatePromise() { + throw C(); + } + truncateSync() { + throw C(); + } + watch() { + throw C(); + } + watchFile() { + throw C(); + } + unwatchFile() { + throw C(); + } + } + f.instance = new f(); + var I = r(39725), + E = r(42096), + B = r(17674), + y = r(53660); + function m(e) { + const t = s.cS.toPortablePath(n().tmpdir()), + r = Math.ceil(4294967296 * Math.random()) + .toString(16) + .padStart(8, '0'); + return s.y1.join(t, `${e}${r}`); + } + function w(e, t) { + const r = new Set([ + 'accessSync', + 'appendFileSync', + 'createReadStream', + 'chmodSync', + 'chownSync', + 'closeSync', + 'copyFileSync', + 'linkSync', + 'lstatSync', + 'lutimesSync', + 'mkdirSync', + 'openSync', + 'opendirSync', + 'readSync', + 'readlinkSync', + 'readFileSync', + 'readdirSync', + 'readlinkSync', + 'realpathSync', + 'renameSync', + 'rmdirSync', + 'statSync', + 'symlinkSync', + 'truncateSync', + 'unlinkSync', + 'unwatchFile', + 'utimesSync', + 'watch', + 'watchFile', + 'writeFileSync', + 'writeSync', + ]), + A = new Set([ + 'accessPromise', + 'appendFilePromise', + 'chmodPromise', + 'chownPromise', + 'closePromise', + 'copyFilePromise', + 'linkPromise', + 'lstatPromise', + 'lutimesPromise', + 'mkdirPromise', + 'openPromise', + 'opendirPromise', + 'readdirPromise', + 'realpathPromise', + 'readFilePromise', + 'readdirPromise', + 'readlinkPromise', + 'renamePromise', + 'rmdirPromise', + 'statPromise', + 'symlinkPromise', + 'truncatePromise', + 'unlinkPromise', + 'utimesPromise', + 'writeFilePromise', + 'writeSync', + ]), + n = new Set([ + 'appendFilePromise', + 'chmodPromise', + 'chownPromise', + 'closePromise', + 'readPromise', + 'readFilePromise', + 'statPromise', + 'truncatePromise', + 'utimesPromise', + 'writePromise', + 'writeFilePromise', + ]), + i = (e, t, r) => { + const A = e[t]; + (e[t] = r), + void 0 !== (null == A ? void 0 : A[o.promisify.custom]) && + (r[o.promisify.custom] = A[o.promisify.custom]); + }; + i(e, 'exists', (e, ...r) => { + const A = 'function' == typeof r[r.length - 1] ? r.pop() : () => {}; + process.nextTick(() => { + t.existsPromise(e).then( + (e) => { + A(e); + }, + () => { + A(!1); + } + ); + }); + }), + i(e, 'read', (e, r, ...A) => { + const n = + 'function' == typeof A[A.length - 1] ? A.pop() : () => {}; + process.nextTick(() => { + t.readPromise(e, r, ...A).then( + (e) => { + n(null, e, r); + }, + (e) => { + n(e); + } + ); + }); + }); + for (const r of A) { + const A = r.replace(/Promise$/, ''); + if (void 0 === e[A]) continue; + const n = t[r]; + if (void 0 === n) continue; + i(e, A, (...e) => { + const r = + 'function' == typeof e[e.length - 1] ? e.pop() : () => {}; + process.nextTick(() => { + n.apply(t, e).then( + (e) => { + r(null, e); + }, + (e) => { + r(e); + } + ); + }); + }); + } + (e.realpath.native = e.realpath), + i(e, 'existsSync', (e) => { + try { + return t.existsSync(e); + } catch (e) { + return !1; + } + }); + for (const A of r) { + const r = A; + if (void 0 === e[r]) continue; + const n = t[A]; + void 0 !== n && i(e, r, n.bind(t)); + } + e.realpathSync.native = e.realpathSync; + { + const r = process.emitWarning; + let o; + process.emitWarning = () => {}; + try { + o = e.promises; + } finally { + process.emitWarning = r; + } + if (void 0 !== o) { + for (const e of A) { + const r = e.replace(/Promise$/, ''); + if (void 0 === o[r]) continue; + const A = t[e]; + void 0 !== A && 'open' !== e && i(o, r, A.bind(t)); + } + class e { + constructor(e) { + this.fd = e; + } + } + for (const r of n) { + const A = r.replace(/Promise$/, ''), + n = t[r]; + void 0 !== n && + i(e.prototype, A, function (...e) { + return n.call(t, this.fd, ...e); + }); + } + i(o, 'open', async (...r) => { + const A = await t.openPromise(...r); + return new e(A); + }); + } + } + e.read[o.promisify.custom] = async (e, r, ...A) => { + const n = t.readPromise(e, r, ...A); + return { bytesRead: await n, buffer: r }; + }; + } + function Q(e, t) { + const r = Object.create(e); + return w(r, t), r; + } + const D = new Set(); + let b = !1; + function v() { + b || + ((b = !0), + process.once('exit', () => { + S.rmtempSync(); + })); + } + const S = Object.assign(new i.S(), { + detachTemp(e) { + D.delete(e); + }, + mktempSync(e) { + for (v(); ; ) { + const t = m('xfs-'); + try { + this.mkdirSync(t); + } catch (e) { + if ('EEXIST' === e.code) continue; + throw e; + } + const r = this.realpathSync(t); + if ((D.add(r), void 0 === e)) return t; + try { + return e(r); + } finally { + if (D.has(r)) { + D.delete(r); + try { + this.removeSync(r); + } catch (e) {} + } + } + } + }, + async mktempPromise(e) { + for (v(); ; ) { + const t = m('xfs-'); + try { + await this.mkdirPromise(t); + } catch (e) { + if ('EEXIST' === e.code) continue; + throw e; + } + const r = await this.realpathPromise(t); + if ((D.add(r), void 0 === e)) return r; + try { + return await e(r); + } finally { + if (D.has(r)) { + D.delete(r); + try { + await this.removePromise(r); + } catch (e) {} + } + } + } + }, + async rmtempPromise() { + await Promise.all( + Array.from(D.values()).map(async (e) => { + try { + await S.removePromise(e, { maxRetries: 0 }), D.delete(e); + } catch (e) {} + }) + ); + }, + rmtempSync() { + for (const e of D) + try { + S.removeSync(e), D.delete(e); + } catch (e) {} + }, + }); + }, + 46009: (e, t, r) => { + 'use strict'; + r.d(t, { + LZ: () => i, + QS: () => s, + cS: () => a, + y1: () => c, + CI: () => f, + Zu: () => I, + }); + var A, + n = r(85622), + o = r.n(n); + !(function (e) { + (e[(e.File = 0)] = 'File'), + (e[(e.Portable = 1)] = 'Portable'), + (e[(e.Native = 2)] = 'Native'); + })(A || (A = {})); + const i = { root: '/', dot: '.' }, + s = { + nodeModules: 'node_modules', + manifest: 'package.json', + lockfile: 'yarn.lock', + pnpJs: '.pnp.js', + rc: '.yarnrc.yml', + }, + a = Object.create(o()), + c = Object.create(o().posix); + (a.cwd = () => process.cwd()), + (c.cwd = () => C(process.cwd())), + (c.resolve = (...e) => + e.length > 0 && c.isAbsolute(e[0]) + ? o().posix.resolve(...e) + : o().posix.resolve(c.cwd(), ...e)); + const g = function (e, t, r) { + return (t = e.normalize(t)) === (r = e.normalize(r)) + ? '.' + : (t.endsWith(e.sep) || (t += e.sep), + r.startsWith(t) ? r.slice(t.length) : null); + }; + (a.fromPortablePath = d), + (a.toPortablePath = C), + (a.contains = (e, t) => g(a, e, t)), + (c.contains = (e, t) => g(c, e, t)); + const l = /^([a-zA-Z]:.*)$/, + u = /^\\\\(\.\\)?(.*)$/, + h = /^\/([a-zA-Z]:.*)$/, + p = /^\/unc\/(\.dot\/)?(.*)$/; + function d(e) { + if ('win32' !== process.platform) return e; + if (e.match(h)) e = e.replace(h, '$1'); + else { + if (!e.match(p)) return e; + e = e.replace(p, (e, t, r) => `\\\\${t ? '.\\' : ''}${r}`); + } + return e.replace(/\//g, '\\'); + } + function C(e) { + return 'win32' !== process.platform + ? e + : (e.match(l) + ? (e = e.replace(l, '/$1')) + : e.match(u) && + (e = e.replace( + u, + (e, t, r) => `/unc/${t ? '.dot/' : ''}${r}` + )), + e.replace(/\\/g, '/')); + } + function f(e, t) { + return e === a ? d(t) : C(t); + } + function I(e) { + if ('' !== a.parse(e).dir || '' !== c.parse(e).dir) + throw new Error(`Invalid filename: "${e}"`); + return e; + } + }, + 65760: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + DirEntry: () => n, + StatEntry: () => o, + makeDefaultStats: () => i, + makeEmptyStats: () => s, + areStatsEqual: () => a, + }); + var A = r(22004); + class n { + constructor() { + (this.name = ''), (this.mode = 0); + } + isBlockDevice() { + return !1; + } + isCharacterDevice() { + return !1; + } + isDirectory() { + return (this.mode & A.wK) === A.QB; + } + isFIFO() { + return !1; + } + isFile() { + return (this.mode & A.wK) === A.Pe; + } + isSocket() { + return !1; + } + isSymbolicLink() { + return (this.mode & A.wK) === A.Zv; + } + } + class o { + constructor() { + (this.dev = 0), + (this.ino = 0), + (this.mode = 0), + (this.nlink = 1), + (this.rdev = 0), + (this.blocks = 1); + } + isBlockDevice() { + return !1; + } + isCharacterDevice() { + return !1; + } + isDirectory() { + return (this.mode & A.wK) === A.QB; + } + isFIFO() { + return !1; + } + isFile() { + return (this.mode & A.wK) === A.Pe; + } + isSocket() { + return !1; + } + isSymbolicLink() { + return (this.mode & A.wK) === A.Zv; + } + } + function i() { + return Object.assign(new o(), { + uid: 0, + gid: 0, + size: 0, + blksize: 0, + atimeMs: 0, + mtimeMs: 0, + ctimeMs: 0, + birthtimeMs: 0, + atime: new Date(0), + mtime: new Date(0), + ctime: new Date(0), + birthtime: new Date(0), + mode: 420 | A.Pe, + }); + } + function s() { + return Object.assign(i(), { nlink: 0, blocks: 0, mode: 0 }); + } + function a(e, t) { + return ( + e.atimeMs === t.atimeMs && + e.birthtimeMs === t.birthtimeMs && + e.blksize === t.blksize && + e.blocks === t.blocks && + e.ctimeMs === t.ctimeMs && + e.dev === t.dev && + e.gid === t.gid && + e.ino === t.ino && + e.isBlockDevice() === t.isBlockDevice() && + e.isCharacterDevice() === t.isCharacterDevice() && + e.isDirectory() === t.isDirectory() && + e.isFIFO() === t.isFIFO() && + e.isFile() === t.isFile() && + e.isSocket() === t.isSocket() && + e.isSymbolicLink() === t.isSymbolicLink() && + e.mode === t.mode && + e.mtimeMs === t.mtimeMs && + e.nlink === t.nlink && + e.rdev === t.rdev && + e.size === t.size && + e.uid === t.uid + ); + } + }, + 65281: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { getLibzipPromise: () => s, getLibzipSync: () => i }); + const A = ['number', 'number']; + var n; + !(function (e) { + (e[(e.ZIP_ER_OK = 0)] = 'ZIP_ER_OK'), + (e[(e.ZIP_ER_MULTIDISK = 1)] = 'ZIP_ER_MULTIDISK'), + (e[(e.ZIP_ER_RENAME = 2)] = 'ZIP_ER_RENAME'), + (e[(e.ZIP_ER_CLOSE = 3)] = 'ZIP_ER_CLOSE'), + (e[(e.ZIP_ER_SEEK = 4)] = 'ZIP_ER_SEEK'), + (e[(e.ZIP_ER_READ = 5)] = 'ZIP_ER_READ'), + (e[(e.ZIP_ER_WRITE = 6)] = 'ZIP_ER_WRITE'), + (e[(e.ZIP_ER_CRC = 7)] = 'ZIP_ER_CRC'), + (e[(e.ZIP_ER_ZIPCLOSED = 8)] = 'ZIP_ER_ZIPCLOSED'), + (e[(e.ZIP_ER_NOENT = 9)] = 'ZIP_ER_NOENT'), + (e[(e.ZIP_ER_EXISTS = 10)] = 'ZIP_ER_EXISTS'), + (e[(e.ZIP_ER_OPEN = 11)] = 'ZIP_ER_OPEN'), + (e[(e.ZIP_ER_TMPOPEN = 12)] = 'ZIP_ER_TMPOPEN'), + (e[(e.ZIP_ER_ZLIB = 13)] = 'ZIP_ER_ZLIB'), + (e[(e.ZIP_ER_MEMORY = 14)] = 'ZIP_ER_MEMORY'), + (e[(e.ZIP_ER_CHANGED = 15)] = 'ZIP_ER_CHANGED'), + (e[(e.ZIP_ER_COMPNOTSUPP = 16)] = 'ZIP_ER_COMPNOTSUPP'), + (e[(e.ZIP_ER_EOF = 17)] = 'ZIP_ER_EOF'), + (e[(e.ZIP_ER_INVAL = 18)] = 'ZIP_ER_INVAL'), + (e[(e.ZIP_ER_NOZIP = 19)] = 'ZIP_ER_NOZIP'), + (e[(e.ZIP_ER_INTERNAL = 20)] = 'ZIP_ER_INTERNAL'), + (e[(e.ZIP_ER_INCONS = 21)] = 'ZIP_ER_INCONS'), + (e[(e.ZIP_ER_REMOVE = 22)] = 'ZIP_ER_REMOVE'), + (e[(e.ZIP_ER_DELETED = 23)] = 'ZIP_ER_DELETED'), + (e[(e.ZIP_ER_ENCRNOTSUPP = 24)] = 'ZIP_ER_ENCRNOTSUPP'), + (e[(e.ZIP_ER_RDONLY = 25)] = 'ZIP_ER_RDONLY'), + (e[(e.ZIP_ER_NOPASSWD = 26)] = 'ZIP_ER_NOPASSWD'), + (e[(e.ZIP_ER_WRONGPASSWD = 27)] = 'ZIP_ER_WRONGPASSWD'), + (e[(e.ZIP_ER_OPNOTSUPP = 28)] = 'ZIP_ER_OPNOTSUPP'), + (e[(e.ZIP_ER_INUSE = 29)] = 'ZIP_ER_INUSE'), + (e[(e.ZIP_ER_TELL = 30)] = 'ZIP_ER_TELL'), + (e[(e.ZIP_ER_COMPRESSED_DATA = 31)] = 'ZIP_ER_COMPRESSED_DATA'); + })(n || (n = {})); + let o = null; + function i() { + var e; + return ( + null === o && + ((e = r(3368)), + (o = { + get HEAP8() { + return e.HEAP8; + }, + get HEAPU8() { + return e.HEAPU8; + }, + errors: n, + SEEK_SET: 0, + SEEK_CUR: 1, + SEEK_END: 2, + ZIP_CHECKCONS: 4, + ZIP_CREATE: 1, + ZIP_EXCL: 2, + ZIP_TRUNCATE: 8, + ZIP_RDONLY: 16, + ZIP_FL_OVERWRITE: 8192, + ZIP_FL_COMPRESSED: 4, + ZIP_OPSYS_DOS: 0, + ZIP_OPSYS_AMIGA: 1, + ZIP_OPSYS_OPENVMS: 2, + ZIP_OPSYS_UNIX: 3, + ZIP_OPSYS_VM_CMS: 4, + ZIP_OPSYS_ATARI_ST: 5, + ZIP_OPSYS_OS_2: 6, + ZIP_OPSYS_MACINTOSH: 7, + ZIP_OPSYS_Z_SYSTEM: 8, + ZIP_OPSYS_CPM: 9, + ZIP_OPSYS_WINDOWS_NTFS: 10, + ZIP_OPSYS_MVS: 11, + ZIP_OPSYS_VSE: 12, + ZIP_OPSYS_ACORN_RISC: 13, + ZIP_OPSYS_VFAT: 14, + ZIP_OPSYS_ALTERNATE_MVS: 15, + ZIP_OPSYS_BEOS: 16, + ZIP_OPSYS_TANDEM: 17, + ZIP_OPSYS_OS_400: 18, + ZIP_OPSYS_OS_X: 19, + ZIP_CM_DEFAULT: -1, + ZIP_CM_STORE: 0, + ZIP_CM_DEFLATE: 8, + uint08S: e._malloc(1), + uint16S: e._malloc(2), + uint32S: e._malloc(4), + uint64S: e._malloc(8), + malloc: e._malloc, + free: e._free, + getValue: e.getValue, + open: e.cwrap('zip_open', 'number', [ + 'string', + 'number', + 'number', + ]), + openFromSource: e.cwrap('zip_open_from_source', 'number', [ + 'number', + 'number', + 'number', + ]), + close: e.cwrap('zip_close', 'number', ['number']), + discard: e.cwrap('zip_discard', null, ['number']), + getError: e.cwrap('zip_get_error', 'number', ['number']), + getName: e.cwrap('zip_get_name', 'string', [ + 'number', + 'number', + 'number', + ]), + getNumEntries: e.cwrap('zip_get_num_entries', 'number', [ + 'number', + 'number', + ]), + delete: e.cwrap('zip_delete', 'number', ['number', 'number']), + stat: e.cwrap('zip_stat', 'number', [ + 'number', + 'string', + 'number', + 'number', + ]), + statIndex: e.cwrap('zip_stat_index', 'number', [ + 'number', + ...A, + 'number', + 'number', + ]), + fopen: e.cwrap('zip_fopen', 'number', [ + 'number', + 'string', + 'number', + ]), + fopenIndex: e.cwrap('zip_fopen_index', 'number', [ + 'number', + ...A, + 'number', + ]), + fread: e.cwrap('zip_fread', 'number', [ + 'number', + 'number', + 'number', + 'number', + ]), + fclose: e.cwrap('zip_fclose', 'number', ['number']), + dir: { + add: e.cwrap('zip_dir_add', 'number', ['number', 'string']), + }, + file: { + add: e.cwrap('zip_file_add', 'number', [ + 'number', + 'string', + 'number', + 'number', + ]), + getError: e.cwrap('zip_file_get_error', 'number', ['number']), + getExternalAttributes: e.cwrap( + 'zip_file_get_external_attributes', + 'number', + ['number', ...A, 'number', 'number', 'number'] + ), + setExternalAttributes: e.cwrap( + 'zip_file_set_external_attributes', + 'number', + ['number', ...A, 'number', 'number', 'number'] + ), + setMtime: e.cwrap('zip_file_set_mtime', 'number', [ + 'number', + ...A, + 'number', + 'number', + ]), + setCompression: e.cwrap( + 'zip_set_file_compression', + 'number', + ['number', ...A, 'number', 'number'] + ), + }, + ext: { + countSymlinks: e.cwrap('zip_ext_count_symlinks', 'number', [ + 'number', + ]), + }, + error: { + initWithCode: e.cwrap('zip_error_init_with_code', null, [ + 'number', + 'number', + ]), + strerror: e.cwrap('zip_error_strerror', 'string', ['number']), + }, + name: { + locate: e.cwrap('zip_name_locate', 'number', [ + 'number', + 'string', + 'number', + ]), + }, + source: { + fromUnattachedBuffer: e.cwrap( + 'zip_source_buffer_create', + 'number', + ['number', 'number', 'number', 'number'] + ), + fromBuffer: e.cwrap('zip_source_buffer', 'number', [ + 'number', + 'number', + ...A, + 'number', + ]), + free: e.cwrap('zip_source_free', null, ['number']), + keep: e.cwrap('zip_source_keep', null, ['number']), + open: e.cwrap('zip_source_open', 'number', ['number']), + close: e.cwrap('zip_source_close', 'number', ['number']), + seek: e.cwrap('zip_source_seek', 'number', [ + 'number', + ...A, + 'number', + ]), + tell: e.cwrap('zip_source_tell', 'number', ['number']), + read: e.cwrap('zip_source_read', 'number', [ + 'number', + 'number', + 'number', + ]), + error: e.cwrap('zip_source_error', 'number', ['number']), + setMtime: e.cwrap('zip_source_set_mtime', 'number', [ + 'number', + 'number', + ]), + }, + struct: { + stat: e.cwrap('zipstruct_stat', 'number', []), + statS: e.cwrap('zipstruct_statS', 'number', []), + statName: e.cwrap('zipstruct_stat_name', 'string', [ + 'number', + ]), + statIndex: e.cwrap('zipstruct_stat_index', 'number', [ + 'number', + ]), + statSize: e.cwrap('zipstruct_stat_size', 'number', [ + 'number', + ]), + statCompSize: e.cwrap('zipstruct_stat_comp_size', 'number', [ + 'number', + ]), + statCompMethod: e.cwrap( + 'zipstruct_stat_comp_method', + 'number', + ['number'] + ), + statMtime: e.cwrap('zipstruct_stat_mtime', 'number', [ + 'number', + ]), + error: e.cwrap('zipstruct_error', 'number', []), + errorS: e.cwrap('zipstruct_errorS', 'number', []), + errorCodeZip: e.cwrap('zipstruct_error_code_zip', 'number', [ + 'number', + ]), + }, + })), + o + ); + } + async function s() { + return i(); + } + }, + 11640: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { + parseResolution: () => i, + parseShell: () => n, + parseSyml: () => I, + stringifyResolution: () => s, + stringifySyml: () => d, + }); + var A = r(92962); + function n(e, t = { isGlobPattern: () => !1 }) { + try { + return (0, A.parse)(e, t); + } catch (e) { + throw ( + (e.location && + (e.message = e.message.replace( + /(\.)?$/, + ` (line ${e.location.start.line}, column ${e.location.start.column})$1` + )), + e) + ); + } + } + var o = r(98261); + function i(e) { + const t = e.match(/^\*{1,2}\/(.*)/); + if (t) + throw new Error( + `The override for '${e}' includes a glob pattern. Glob patterns have been removed since their behaviours don't match what you'd expect. Set the override to '${t[1]}' instead.` + ); + try { + return (0, o.parse)(e); + } catch (e) { + throw ( + (e.location && + (e.message = e.message.replace( + /(\.)?$/, + ` (line ${e.location.start.line}, column ${e.location.start.column})$1` + )), + e) + ); + } + } + function s(e) { + let t = ''; + return ( + e.from && + ((t += e.from.fullName), + e.from.description && (t += '@' + e.from.description), + (t += '/')), + (t += e.descriptor.fullName), + e.descriptor.description && (t += '@' + e.descriptor.description), + t + ); + } + var a = r(21194), + c = r(85443); + const g = /^(?![-?:,\][{}#&*!|>'"%@` \t\r\n]).([ \t]*(?![,\][{}:# \t\r\n]).)*$/, + l = [ + '__metadata', + 'version', + 'resolution', + 'dependencies', + 'peerDependencies', + 'dependenciesMeta', + 'peerDependenciesMeta', + 'binaries', + ]; + class u { + constructor(e) { + this.data = e; + } + } + function h(e) { + return e.match(g) ? e : JSON.stringify(e); + } + function p(e, t, r) { + if (null === e) return 'null\n'; + if ('number' == typeof e || 'boolean' == typeof e) + return e.toString() + '\n'; + if ('string' == typeof e) return h(e) + '\n'; + if (Array.isArray(e)) { + if (0 === e.length) return '[]\n'; + const r = ' '.repeat(t); + return '\n' + e.map((e) => `${r}- ${p(e, t + 1, !1)}`).join(''); + } + if ('object' == typeof e && e) { + let A, n; + e instanceof u ? ((A = e.data), (n = !1)) : ((A = e), (n = !0)); + const o = ' '.repeat(t), + i = Object.keys(A); + n && + i.sort((e, t) => { + const r = l.indexOf(e), + A = l.indexOf(t); + return -1 === r && -1 === A + ? e < t + ? -1 + : e > t + ? 1 + : 0 + : -1 !== r && -1 === A + ? -1 + : -1 === r && -1 !== A + ? 1 + : r - A; + }); + const s = + i + .filter( + (e) => + !(function e(t) { + return ( + void 0 === t || + ('object' == typeof t && + null !== t && + Object.keys(t).every((r) => e(t[r]))) + ); + })(A[e]) + ) + .map((e, n) => { + const i = A[e], + s = h(e), + a = p(i, t + 1, !0), + c = n > 0 || r ? o : ''; + return a.startsWith('\n') + ? `${c}${s}:${a}` + : `${c}${s}: ${a}`; + }) + .join(0 === t ? '\n' : '') || '\n'; + return r ? '\n' + s : '' + s; + } + throw new Error(`Unsupported value type (${e})`); + } + function d(e) { + try { + const t = p(e, 0, !1); + return '\n' !== t ? t : ''; + } catch (e) { + throw ( + (e.location && + (e.message = e.message.replace( + /(\.)?$/, + ` (line ${e.location.start.line}, column ${e.location.start.column})$1` + )), + e) + ); + } + } + d.PreserveOrdering = u; + const C = /^(#.*(\r?\n))*?#\s+yarn\s+lockfile\s+v1\r?\n/i; + function f(e) { + if (C.test(e)) + return (function (e) { + return e.endsWith('\n') || (e += '\n'), (0, c.parse)(e); + })(e); + const t = (0, a.safeLoad)(e, { schema: a.FAILSAFE_SCHEMA }); + if (null == t) return {}; + if ('object' != typeof t) + throw new Error( + `Expected an indexed object, got a ${typeof t} instead. Does your file follow Yaml's rules?` + ); + if (Array.isArray(t)) + throw new Error( + "Expected an indexed object, got an array instead. Does your file follow Yaml's rules?" + ); + return t; + } + function I(e) { + return f(e); + } + }, + 34432: (e, t, r) => { + 'use strict'; + var A, n; + r.d(t, { gY: () => E, Q$: () => B, oC: () => F }), + (function (e) { + (e.HARD = 'HARD'), (e.SOFT = 'SOFT'); + })(A || (A = {})), + (function (e) { + (e.DEFAULT = 'DEFAULT'), + (e.TOP_LEVEL = 'TOP_LEVEL'), + (e.FALLBACK_EXCLUSION_LIST = 'FALLBACK_EXCLUSION_LIST'), + (e.FALLBACK_EXCLUSION_ENTRIES = 'FALLBACK_EXCLUSION_ENTRIES'), + (e.FALLBACK_EXCLUSION_DATA = 'FALLBACK_EXCLUSION_DATA'), + (e.PACKAGE_REGISTRY_DATA = 'PACKAGE_REGISTRY_DATA'), + (e.PACKAGE_REGISTRY_ENTRIES = 'PACKAGE_REGISTRY_ENTRIES'), + (e.PACKAGE_STORE_DATA = 'PACKAGE_STORE_DATA'), + (e.PACKAGE_STORE_ENTRIES = 'PACKAGE_STORE_ENTRIES'), + (e.PACKAGE_INFORMATION_DATA = 'PACKAGE_INFORMATION_DATA'), + (e.PACKAGE_DEPENDENCIES = 'PACKAGE_DEPENDENCIES'), + (e.PACKAGE_DEPENDENCY = 'PACKAGE_DEPENDENCY'); + })(n || (n = {})); + const o = { + [n.DEFAULT]: { collapsed: !1, next: { '*': n.DEFAULT } }, + [n.TOP_LEVEL]: { + collapsed: !1, + next: { + fallbackExclusionList: n.FALLBACK_EXCLUSION_LIST, + packageRegistryData: n.PACKAGE_REGISTRY_DATA, + '*': n.DEFAULT, + }, + }, + [n.FALLBACK_EXCLUSION_LIST]: { + collapsed: !1, + next: { '*': n.FALLBACK_EXCLUSION_ENTRIES }, + }, + [n.FALLBACK_EXCLUSION_ENTRIES]: { + collapsed: !0, + next: { '*': n.FALLBACK_EXCLUSION_DATA }, + }, + [n.FALLBACK_EXCLUSION_DATA]: { + collapsed: !0, + next: { '*': n.DEFAULT }, + }, + [n.PACKAGE_REGISTRY_DATA]: { + collapsed: !1, + next: { '*': n.PACKAGE_REGISTRY_ENTRIES }, + }, + [n.PACKAGE_REGISTRY_ENTRIES]: { + collapsed: !0, + next: { '*': n.PACKAGE_STORE_DATA }, + }, + [n.PACKAGE_STORE_DATA]: { + collapsed: !1, + next: { '*': n.PACKAGE_STORE_ENTRIES }, + }, + [n.PACKAGE_STORE_ENTRIES]: { + collapsed: !0, + next: { '*': n.PACKAGE_INFORMATION_DATA }, + }, + [n.PACKAGE_INFORMATION_DATA]: { + collapsed: !1, + next: { + packageDependencies: n.PACKAGE_DEPENDENCIES, + '*': n.DEFAULT, + }, + }, + [n.PACKAGE_DEPENDENCIES]: { + collapsed: !1, + next: { '*': n.PACKAGE_DEPENDENCY }, + }, + [n.PACKAGE_DEPENDENCY]: { collapsed: !0, next: { '*': n.DEFAULT } }, + }; + function i(e, t, r, A) { + const { next: n } = o[r]; + return s(t, n[e] || n['*'], A); + } + function s(e, t, r) { + const { collapsed: A } = o[t]; + return Array.isArray(e) + ? A + ? (function (e, t, r) { + let A = ''; + A += '['; + for (let n = 0, o = e.length; n < o; ++n) + (A += i(String(n), e[n], t, r).replace(/^ +/g, '')), + n + 1 < o && (A += ', '); + return (A += ']'), A; + })(e, t, r) + : (function (e, t, r) { + const A = r + ' '; + let n = ''; + (n += r), (n += '[\n'); + for (let r = 0, o = e.length; r < o; ++r) + (n += A + i(String(r), e[r], t, A).replace(/^ +/, '')), + r + 1 < o && (n += ','), + (n += '\n'); + return (n += r), (n += ']'), n; + })(e, t, r) + : 'object' == typeof e && null !== e + ? A + ? (function (e, t, r) { + const A = Object.keys(e); + let n = ''; + n += '{'; + for (let o = 0, s = A.length; o < s; ++o) { + const a = A[o], + c = e[a]; + void 0 !== c && + ((n += JSON.stringify(a)), + (n += ': '), + (n += i(a, c, t, r).replace(/^ +/g, '')), + o + 1 < s && (n += ', ')); + } + return (n += '}'), n; + })(e, t, r) + : (function (e, t, r) { + const A = Object.keys(e), + n = r + ' '; + let o = ''; + (o += r), (o += '{\n'); + for (let r = 0, s = A.length; r < s; ++r) { + const a = A[r], + c = e[a]; + void 0 !== c && + ((o += n), + (o += JSON.stringify(a)), + (o += ': '), + (o += i(a, c, t, n).replace(/^ +/g, '')), + r + 1 < s && (o += ','), + (o += '\n')); + } + return (o += r), (o += '}'), o; + })(e, t, r) + : JSON.stringify(e); + } + function a(e) { + return s(e, n.TOP_LEVEL, ''); + } + function c(e, t) { + const r = Array.from(e); + Array.isArray(t) || (t = [t]); + const A = []; + for (const e of t) A.push(r.map((t) => e(t))); + const n = r.map((e, t) => t); + return ( + n.sort((e, t) => { + for (const r of A) { + const A = r[e] < r[t] ? -1 : r[e] > r[t] ? 1 : 0; + if (0 !== A) return A; + } + return 0; + }), + n.map((e) => r[e]) + ); + } + function g(e) { + const t = new Map(), + r = c(e.fallbackExclusionList || [], [ + ({ name: e, reference: t }) => e, + ({ name: e, reference: t }) => t, + ]); + for (const { name: e, reference: A } of r) { + let r = t.get(e); + void 0 === r && t.set(e, (r = new Set())), r.add(A); + } + return Array.from(t).map(([e, t]) => [e, Array.from(t)]); + } + function l(e) { + return c(e.fallbackPool || [], ([e]) => e); + } + function u(e) { + const t = []; + for (const [r, A] of c(e.packageRegistry, ([e]) => + null === e ? '0' : '1' + e + )) { + const e = []; + t.push([r, e]); + for (const [ + t, + { + packageLocation: n, + packageDependencies: o, + packagePeers: i, + linkType: s, + discardFromLookup: a, + }, + ] of c(A, ([e]) => (null === e ? '0' : '1' + e))) { + const A = []; + null === r || null === t || o.has(r) || A.push([r, t]); + for (const [e, t] of c(o.entries(), ([e]) => e)) A.push([e, t]); + const g = i && i.size > 0 ? Array.from(i) : void 0, + l = a || void 0; + e.push([ + t, + { + packageLocation: n, + packageDependencies: A, + packagePeers: g, + linkType: s, + discardFromLookup: l, + }, + ]); + } + } + return t; + } + function h(e) { + return c(e.blacklistedLocations || [], (e) => e); + } + function p(e) { + return { + __info: [ + 'This file is automatically generated. Do not touch it, or risk', + 'your modifications being lost. We also recommend you not to read', + 'it either without using the @yarnpkg/pnp package, as the data layout', + 'is entirely unspecified and WILL change from a version to another.', + ], + dependencyTreeRoots: e.dependencyTreeRoots, + enableTopLevelFallback: e.enableTopLevelFallback || !1, + ignorePatternData: e.ignorePattern || null, + fallbackExclusionList: g(e), + fallbackPool: l(e), + locationBlacklistData: h(e), + packageRegistryData: u(e), + }; + } + var d = r(20103), + C = r.n(d); + function f(e, t) { + return [ + e ? e + '\n' : '', + '/* eslint-disable */\n\n', + 'try {\n', + ' Object.freeze({}).detectStrictMode = true;\n', + '} catch (error) {\n', + " throw new Error(`The whole PnP file got strict-mode-ified, which is known to break (Emscripten libraries aren't strict mode). This usually happens when the file goes through Babel.`);\n", + '}\n', + '\n', + 'var __non_webpack_module__ = module;\n', + '\n', + 'function $$SETUP_STATE(hydrateRuntimeState, basePath) {\n', + t.replace(/^/gm, ' '), + '}\n', + '\n', + C()(), + ].join(''); + } + function I(e) { + return JSON.stringify(e, null, 2); + } + function E(e) { + const t = (function (e) { + return [ + `return hydrateRuntimeState(${a( + e + )}, {basePath: basePath || __dirname});\n`, + ].join(''); + })(p(e)); + return f(e.shebang, t); + } + function B(e) { + const t = p(e), + r = + ((A = e.dataLocation), + [ + "var path = require('path');\n", + `var dataLocation = path.resolve(__dirname, ${JSON.stringify( + A + )});\n`, + 'return hydrateRuntimeState(require(dataLocation), {basePath: basePath || path.dirname(dataLocation)});\n', + ].join('')); + var A; + const n = f(e.shebang, r); + return { dataFile: I(t), loaderFile: n }; + } + var y = r(35747), + m = (r(85622), r(31669)), + w = r(46009); + var Q, + D = r(17674), + b = r(32282); + !(function (e) { + (e.API_ERROR = 'API_ERROR'), + (e.BLACKLISTED = 'BLACKLISTED'), + (e.BUILTIN_NODE_RESOLUTION_FAILED = + 'BUILTIN_NODE_RESOLUTION_FAILED'), + (e.MISSING_DEPENDENCY = 'MISSING_DEPENDENCY'), + (e.MISSING_PEER_DEPENDENCY = 'MISSING_PEER_DEPENDENCY'), + (e.QUALIFIED_PATH_RESOLUTION_FAILED = + 'QUALIFIED_PATH_RESOLUTION_FAILED'), + (e.INTERNAL = 'INTERNAL'), + (e.UNDECLARED_DEPENDENCY = 'UNDECLARED_DEPENDENCY'), + (e.UNSUPPORTED = 'UNSUPPORTED'); + })(Q || (Q = {})); + const v = new Set([ + Q.BLACKLISTED, + Q.BUILTIN_NODE_RESOLUTION_FAILED, + Q.MISSING_DEPENDENCY, + Q.MISSING_PEER_DEPENDENCY, + Q.QUALIFIED_PATH_RESOLUTION_FAILED, + Q.UNDECLARED_DEPENDENCY, + ]); + function S(e, t, r = {}) { + const A = v.has(e) ? 'MODULE_NOT_FOUND' : e, + n = { configurable: !0, writable: !0, enumerable: !1 }; + return Object.defineProperties(new Error(t), { + code: { ...n, value: A }, + pnpCode: { ...n, value: e }, + data: { ...n, value: r }, + }); + } + function k(e) { + return w.cS.normalize(w.cS.fromPortablePath(e)); + } + function N(e, t) { + const r = Number(process.env.PNP_ALWAYS_WARN_ON_FALLBACK) > 0, + A = Number(process.env.PNP_DEBUG_LEVEL), + n = new Set( + b.Module.builtinModules || Object.keys(process.binding('natives')) + ), + o = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:@[^/]+\/)?[^/]+)\/*(.*|)$/, + i = /^(\/|\.{1,2}(\/|$))/, + s = /\/$/, + a = { name: null, reference: null }, + c = [], + g = new Set(); + if ( + (!0 === e.enableTopLevelFallback && c.push(a), + !1 !== t.compatibilityMode) + ) + for (const t of ['react-scripts', 'gatsby']) { + const r = e.packageRegistry.get(t); + if (r) + for (const e of r.keys()) { + if (null === e) + throw new Error( + "Assertion failed: This reference shouldn't be null" + ); + c.push({ name: t, reference: e }); + } + } + const { + ignorePattern: l, + packageRegistry: u, + packageLocatorsByLocations: h, + packageLocationLengths: p, + } = e; + function d(e, t) { + return { fn: e, args: t, error: null, result: null }; + } + function C(e, r) { + if (!1 === t.allowDebug) return r; + if (Number.isFinite(A)) { + if (A >= 2) + return (...t) => { + const A = d(e, t); + try { + return (A.result = r(...t)); + } catch (e) { + throw (A.error = e); + } finally { + console.trace(A); + } + }; + if (A >= 1) + return (...t) => { + try { + return r(...t); + } catch (r) { + const A = d(e, t); + throw ((A.error = r), console.trace(A), r); + } + }; + } + return r; + } + function f(e) { + const t = y(e); + if (!t) + throw S( + Q.INTERNAL, + "Couldn't find a matching entry in the dependency tree for the specified parent (this is probably an internal error)" + ); + return t; + } + function I(t) { + if (null === t.name) return !0; + for (const r of e.dependencyTreeRoots) + if (r.name === t.name && r.reference === t.reference) return !0; + return !1; + } + function E(e, t) { + return ( + t.endsWith('/') && (t = w.y1.join(t, 'internal.js')), + b.Module._resolveFilename( + w.cS.fromPortablePath(e), + (function (e) { + const t = new b.Module(e, null); + return ( + (t.filename = e), + (t.paths = b.Module._nodeModulePaths(e)), + t + ); + })(w.cS.fromPortablePath(t)), + !1, + { plugnplay: !1 } + ) + ); + } + function B(t) { + if (null === l) return !1; + const r = w.y1.contains(e.basePath, t); + return null !== r && !!l.test(r.replace(/\/$/, '')); + } + function y({ name: e, reference: t }) { + const r = u.get(e); + if (!r) return null; + const A = r.get(t); + return A || null; + } + function m(e, t) { + const r = new Map(), + A = new Set(), + n = (t) => { + const o = JSON.stringify(t.name); + if (A.has(o)) return; + A.add(o); + const i = (function ({ name: e, reference: t }) { + const r = []; + for (const [A, n] of u) + if (null !== A) + for (const [o, i] of n) { + if (null === o) continue; + i.packageDependencies.get(e) === t && + ((A === e && o === t) || + r.push({ name: A, reference: o })); + } + return r; + })(t); + for (const t of i) { + if (f(t).packagePeers.has(e)) n(t); + else { + let e = r.get(t.name); + void 0 === e && r.set(t.name, (e = new Set())), + e.add(t.reference); + } + } + }; + n(t); + const o = []; + for (const e of [...r.keys()].sort()) + for (const t of [...r.get(e)].sort()) + o.push({ name: e, reference: t }); + return o; + } + function v(t) { + if (B(t)) return null; + let r = + ((A = w.y1.relative(e.basePath, t)), w.cS.toPortablePath(A)); + var A; + r.match(i) || (r = './' + r), + t.match(s) && !r.endsWith('/') && (r += '/'); + let n = 0; + for (; n < p.length && p[n] > r.length; ) n += 1; + for (let e = n; e < p.length; ++e) { + const A = h.get(r.substr(0, p[e])); + if (void 0 !== A) { + if (null === A) { + const e = k(t); + throw S( + Q.BLACKLISTED, + "A forbidden path has been used in the package resolution process - this is usually caused by one of your tools calling 'fs.realpath' on the return value of 'require.resolve'. Since we need to use symlinks to simultaneously provide valid filesystem paths and disambiguate peer dependencies, they must be passed untransformed to 'require'.\n\nForbidden path: " + + e, + { location: e } + ); + } + return A; + } + } + return null; + } + function N(A, i, { considerBuiltins: a = !0 } = {}) { + if ('pnpapi' === A) return w.cS.toPortablePath(t.pnpapiResolution); + if (a && n.has(A)) return null; + const l = k(A), + u = i && k(i); + if (i && B(i) && (!w.y1.isAbsolute(A) || null === v(A))) { + const e = E(A, i); + if (!1 === e) + throw S( + Q.BUILTIN_NODE_RESOLUTION_FAILED, + `The builtin node resolution algorithm was unable to resolve the requested module (it didn't go through the pnp resolver because the issuer was explicitely ignored by the regexp)\n\nRequire request: "${l}"\nRequired by: ${u}\n`, + { request: l, issuer: u } + ); + return w.cS.toPortablePath(e); + } + let h; + const p = A.match(o); + if (p) { + if (!i) + throw S( + Q.API_ERROR, + "The resolveToUnqualified function must be called with a valid issuer when the path isn't a builtin nor absolute", + { request: l, issuer: u } + ); + const [, t, o] = p, + s = v(i); + if (!s) { + const e = E(A, i); + if (!1 === e) + throw S( + Q.BUILTIN_NODE_RESOLUTION_FAILED, + `The builtin node resolution algorithm was unable to resolve the requested module (it didn't go through the pnp resolver because the issuer doesn't seem to be part of the Yarn-managed dependency tree).\n\nRequire path: "${l}"\nRequired by: ${u}\n`, + { request: l, issuer: u } + ); + return w.cS.toPortablePath(e); + } + let d = f(s).packageDependencies.get(t), + C = null; + if (null == d && null !== s.name) { + const A = e.fallbackExclusionList.get(s.name); + if (!A || !A.has(s.reference)) { + for (let e = 0, A = c.length; e < A; ++e) { + const A = f(c[e]).packageDependencies.get(t); + if (null != A) { + r ? (C = A) : (d = A); + break; + } + } + if (e.enableTopLevelFallback && null == d && null === C) { + const r = e.fallbackPool.get(t); + null != r && (C = r); + } + } + } + let B = null; + if (null === d) + if (I(s)) + B = S( + Q.MISSING_PEER_DEPENDENCY, + `Your application tried to access ${t} (a peer dependency); this isn't allowed as there is no ancestor to satisfy the requirement. Use a devDependency if needed.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${u}\n`, + { request: l, issuer: u, dependencyName: t } + ); + else { + const e = m(t, s); + B = e.every((e) => I(e)) + ? S( + Q.MISSING_PEER_DEPENDENCY, + `${ + s.name + } tried to access ${t} (a peer dependency) but it isn't provided by your application; this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${ + s.name + }@${s.reference} (via ${u})\n${e + .map( + (e) => + `Ancestor breaking the chain: ${e.name}@${e.reference}\n` + ) + .join('')}\n`, + { + request: l, + issuer: u, + issuerLocator: Object.assign({}, s), + dependencyName: t, + brokenAncestors: e, + } + ) + : S( + Q.MISSING_PEER_DEPENDENCY, + `${ + s.name + } tried to access ${t} (a peer dependency) but it isn't provided by its ancestors; this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${ + s.name + }@${s.reference} (via ${u})\n${e + .map( + (e) => + `Ancestor breaking the chain: ${e.name}@${e.reference}\n` + ) + .join('')}\n`, + { + request: l, + issuer: u, + issuerLocator: Object.assign({}, s), + dependencyName: t, + brokenAncestors: e, + } + ); + } + else + void 0 === d && + (B = + !a && n.has(A) + ? I(s) + ? S( + Q.UNDECLARED_DEPENDENCY, + `Your application tried to access ${t}. While this module is usually interpreted as a Node builtin, your resolver is running inside a non-Node resolution context where such builtins are ignored. Since ${t} isn't otherwise declared in your dependencies, this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${u}\n`, + { request: l, issuer: u, dependencyName: t } + ) + : S( + Q.UNDECLARED_DEPENDENCY, + `${s.name} tried to access ${t}. While this module is usually interpreted as a Node builtin, your resolver is running inside a non-Node resolution context where such builtins are ignored. Since ${t} isn't otherwise declared in ${s.name}'s dependencies, this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${u}\n`, + { + request: l, + issuer: u, + issuerLocator: Object.assign({}, s), + dependencyName: t, + } + ) + : I(s) + ? S( + Q.UNDECLARED_DEPENDENCY, + `Your application tried to access ${t}, but it isn't declared in your dependencies; this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${u}\n`, + { request: l, issuer: u, dependencyName: t } + ) + : S( + Q.UNDECLARED_DEPENDENCY, + `${s.name} tried to access ${t}, but it isn't declared in its dependencies; this makes the require call ambiguous and unsound.\n\nRequired package: ${t} (via "${l}")\nRequired by: ${s.name}@${s.reference} (via ${u})\n`, + { + request: l, + issuer: u, + issuerLocator: Object.assign({}, s), + dependencyName: t, + } + )); + if (null == d) { + if (null === C || null === B) + throw ( + B || + new Error( + 'Assertion failed: Expected an error to have been set' + ) + ); + d = C; + const e = B.message.replace(/\n.*/g, ''); + (B.message = e), g.has(e) || (g.add(e), process.emitWarning(B)); + } + const y = Array.isArray(d) + ? { name: d[0], reference: d[1] } + : { name: t, reference: d }, + D = f(y); + if (!D.packageLocation) + throw S( + Q.MISSING_DEPENDENCY, + `A dependency seems valid but didn't get installed for some reason. This might be caused by a partial install, such as dev vs prod.\n\nRequired package: ${y.name}@${y.reference} (via "${l}")\nRequired by: ${s.name}@${s.reference} (via ${u})\n`, + { + request: l, + issuer: u, + dependencyLocator: Object.assign({}, y), + } + ); + const b = D.packageLocation; + h = o ? w.y1.join(b, o) : b; + } else { + if (w.y1.isAbsolute(A)) h = w.y1.normalize(A); + else { + if (!i) + throw S( + Q.API_ERROR, + "The resolveToUnqualified function must be called with a valid issuer when the path isn't a builtin nor absolute", + { request: l, issuer: u } + ); + const e = w.y1.resolve(i); + h = i.match(s) + ? w.y1.normalize(w.y1.join(e, A)) + : w.y1.normalize(w.y1.join(w.y1.dirname(e), A)); + } + v(h); + } + return w.y1.normalize(h); + } + function F( + e, + { extensions: r = Object.keys(b.Module._extensions) } = {} + ) { + const A = [], + n = (function e(r, A, { extensions: n }) { + let o; + try { + A.push(r), (o = t.fakeFs.statSync(r)); + } catch (e) {} + if (o && !o.isDirectory()) return t.fakeFs.realpathSync(r); + if (o && o.isDirectory()) { + let o, i; + try { + o = JSON.parse( + t.fakeFs.readFileSync( + w.y1.join(r, 'package.json'), + 'utf8' + ) + ); + } catch (e) {} + if ( + (o && o.main && (i = w.y1.resolve(r, o.main)), i && i !== r) + ) { + const t = e(i, A, { extensions: n }); + if (null !== t) return t; + } + } + for (let e = 0, o = n.length; e < o; e++) { + const o = `${r}${n[e]}`; + if ((A.push(o), t.fakeFs.existsSync(o))) return o; + } + if (o && o.isDirectory()) + for (let e = 0, o = n.length; e < o; e++) { + const o = w.y1.format({ dir: r, name: 'index', ext: n[e] }); + if ((A.push(o), t.fakeFs.existsSync(o))) return o; + } + return null; + })(e, A, { extensions: r }); + if (n) return w.y1.normalize(n); + { + const t = k(e); + throw S( + Q.QUALIFIED_PATH_RESOLUTION_FAILED, + `Qualified path resolution failed - none of the candidates can be found on the disk.\n\nSource path: ${t}\n${A.map( + (e) => `Rejected candidate: ${k(e)}\n` + ).join('')}`, + { unqualifiedPath: t } + ); + } + } + return { + VERSIONS: { std: 3, resolveVirtual: 1, getAllLocators: 1 }, + topLevel: a, + getLocator: (e, t) => + Array.isArray(t) + ? { name: t[0], reference: t[1] } + : { name: e, reference: t }, + getDependencyTreeRoots: () => [...e.dependencyTreeRoots], + getAllLocators() { + const e = []; + for (const [t, r] of u) + for (const A of r.keys()) + null !== t && null !== A && e.push({ name: t, reference: A }); + return e; + }, + getPackageInformation: (e) => { + const t = y(e); + if (null === t) return null; + const r = w.cS.fromPortablePath(t.packageLocation); + return { ...t, packageLocation: r }; + }, + findPackageLocator: (e) => v(w.cS.toPortablePath(e)), + resolveToUnqualified: C('resolveToUnqualified', (e, t, r) => { + const A = null !== t ? w.cS.toPortablePath(t) : null, + n = N(w.cS.toPortablePath(e), A, r); + return null === n ? null : w.cS.fromPortablePath(n); + }), + resolveUnqualified: C('resolveUnqualified', (e, t) => + w.cS.fromPortablePath(F(w.cS.toPortablePath(e), t)) + ), + resolveRequest: C('resolveRequest', (e, t, r) => { + const A = null !== t ? w.cS.toPortablePath(t) : null, + n = (function ( + e, + t, + { considerBuiltins: r, extensions: A } = {} + ) { + const n = N(e, t, { considerBuiltins: r }); + if (null === n) return null; + try { + return F(n, { extensions: A }); + } catch (r) { + throw ( + ('QUALIFIED_PATH_RESOLUTION_FAILED' === r.pnpCode && + Object.assign(r.data, { + request: k(e), + issuer: t && k(t), + }), + r) + ); + } + })(w.cS.toPortablePath(e), A, r); + return null === n ? null : w.cS.fromPortablePath(n); + }), + resolveVirtual: C('resolveVirtual', (e) => { + const t = (function (e) { + const t = w.y1.normalize(e), + r = D.p.resolveVirtual(t); + return r !== t ? r : null; + })(w.cS.toPortablePath(e)); + return null !== t ? w.cS.fromPortablePath(t) : null; + }), + }; + } + (0, m.promisify)(y.readFile); + const F = (e, t, r) => + N( + (function (e, { basePath: t }) { + const r = w.cS.toPortablePath(t), + A = w.y1.resolve(r), + n = + null !== e.ignorePatternData + ? new RegExp(e.ignorePatternData) + : null, + o = new Map( + e.packageRegistryData.map(([e, t]) => [ + e, + new Map( + t.map(([e, t]) => [ + e, + { + packageLocation: w.y1.join(A, t.packageLocation), + packageDependencies: new Map(t.packageDependencies), + packagePeers: new Set(t.packagePeers), + linkType: t.linkType, + discardFromLookup: t.discardFromLookup || !1, + }, + ]) + ), + ]) + ), + i = new Map(), + s = new Set(); + for (const [t, r] of e.packageRegistryData) + for (const [e, A] of r) { + if ((null === t) != (null === e)) + throw new Error( + 'Assertion failed: The name and reference should be null, or neither should' + ); + if (A.discardFromLookup) continue; + const r = { name: t, reference: e }; + i.set(A.packageLocation, r), s.add(A.packageLocation.length); + } + for (const t of e.locationBlacklistData) i.set(t, null); + const a = new Map( + e.fallbackExclusionList.map(([e, t]) => [e, new Set(t)]) + ), + c = new Map(e.fallbackPool); + return { + basePath: r, + dependencyTreeRoots: e.dependencyTreeRoots, + enableTopLevelFallback: e.enableTopLevelFallback, + fallbackExclusionList: a, + fallbackPool: c, + ignorePattern: n, + packageLocationLengths: [...s].sort((e, t) => t - e), + packageLocatorsByLocations: i, + packageRegistry: o, + }; + })(p(e), { basePath: t }), + { fakeFs: r, pnpapiResolution: w.cS.join(t, '.pnp.js') } + ); + }, + 76756: (e, t, r) => { + 'use strict'; + r.r(t), + r.d(t, { ShellError: () => c, execute: () => Z, globUtils: () => A }); + var A = {}; + r.r(A), + r.d(A, { + fastGlobOptions: () => E, + isBraceExpansion: () => m, + isGlobPattern: () => B, + match: () => y, + micromatchOptions: () => I, + }); + var n = r(46009), + o = r(78420), + i = r(11640), + s = r(12087), + a = r(92413); + class c extends Error { + constructor(e) { + super(e), (this.name = 'ShellError'); + } + } + var g = r(43896), + l = r(39725), + u = r(19347), + h = r.n(u), + p = r(35747), + d = r.n(p), + C = r(2401), + f = r.n(C); + const I = { strictBrackets: !0 }, + E = { onlyDirectories: !1, onlyFiles: !1 }; + function B(e) { + if (!f().scan(e, I).isGlob) return !1; + try { + f().parse(e, I); + } catch (e) { + return !1; + } + return !0; + } + function y(e, { cwd: t, baseFs: r }) { + return h()(e, { + ...E, + cwd: n.cS.fromPortablePath(t), + fs: (0, g.extendFs)(d(), new l.i(r)), + }); + } + function m(e) { + return f().scan(e, I).isBrace; + } + var w, + Q = r(67566), + D = r.n(Q); + function b() {} + !(function (e) { + (e[(e.STDIN = 0)] = 'STDIN'), + (e[(e.STDOUT = 1)] = 'STDOUT'), + (e[(e.STDERR = 2)] = 'STDERR'); + })(w || (w = {})); + let v = 0; + class S { + constructor(e) { + this.stream = e; + } + close() {} + get() { + return this.stream; + } + } + class k { + constructor() { + this.stream = null; + } + close() { + if (null === this.stream) + throw new Error('Assertion failed: No stream attached'); + this.stream.end(); + } + attach(e) { + this.stream = e; + } + get() { + if (null === this.stream) + throw new Error('Assertion failed: No stream attached'); + return this.stream; + } + } + class N { + constructor(e, t) { + (this.stdin = null), + (this.stdout = null), + (this.stderr = null), + (this.pipe = null), + (this.ancestor = e), + (this.implementation = t); + } + static start(e, { stdin: t, stdout: r, stderr: A }) { + const n = new N(null, e); + return (n.stdin = t), (n.stdout = r), (n.stderr = A), n; + } + pipeTo(e, t = w.STDOUT) { + const r = new N(this, e), + A = new k(); + return ( + (r.pipe = A), + (r.stdout = this.stdout), + (r.stderr = this.stderr), + (t & w.STDOUT) === w.STDOUT + ? (this.stdout = A) + : null !== this.ancestor && + (this.stderr = this.ancestor.stdout), + (t & w.STDERR) === w.STDERR + ? (this.stderr = A) + : null !== this.ancestor && + (this.stderr = this.ancestor.stderr), + r + ); + } + async exec() { + const e = ['ignore', 'ignore', 'ignore']; + if (this.pipe) e[0] = 'pipe'; + else { + if (null === this.stdin) + throw new Error('Assertion failed: No input stream registered'); + e[0] = this.stdin.get(); + } + let t, r; + if (null === this.stdout) + throw new Error('Assertion failed: No output stream registered'); + if (((t = this.stdout), (e[1] = t.get()), null === this.stderr)) + throw new Error('Assertion failed: No error stream registered'); + (r = this.stderr), (e[2] = r.get()); + const A = this.implementation(e); + return ( + this.pipe && this.pipe.attach(A.stdin), + await A.promise.then((e) => (t.close(), r.close(), e)) + ); + } + async run() { + const e = []; + for (let t = this; t; t = t.ancestor) e.push(t.exec()); + return (await Promise.all(e))[0]; + } + } + function F(e, t) { + return N.start(e, t); + } + var K; + function M(e, t, r) { + const A = new a.PassThrough({ autoDestroy: !0 }); + switch (e) { + case w.STDIN: + (t & K.Readable) === K.Readable && r.stdin.pipe(A, { end: !1 }), + (t & K.Writable) === K.Writable && + r.stdin instanceof a.Writable && + A.pipe(r.stdin, { end: !1 }); + break; + case w.STDOUT: + (t & K.Readable) === K.Readable && r.stdout.pipe(A, { end: !1 }), + (t & K.Writable) === K.Writable && + A.pipe(r.stdout, { end: !1 }); + break; + case w.STDERR: + (t & K.Readable) === K.Readable && r.stderr.pipe(A, { end: !1 }), + (t & K.Writable) === K.Writable && + A.pipe(r.stderr, { end: !1 }); + break; + default: + throw new c(`Bad file descriptor: "${e}"`); + } + return A; + } + function R(e, t = {}) { + const r = { ...e, ...t }; + return ( + (r.environment = { ...e.environment, ...t.environment }), + (r.variables = { ...e.variables, ...t.variables }), + r + ); + } + !(function (e) { + (e[(e.Readable = 1)] = 'Readable'), + (e[(e.Writable = 2)] = 'Writable'); + })(K || (K = {})); + const x = new Map([ + [ + 'cd', + async ([e = (0, s.homedir)(), ...t], r, A) => { + const o = n.y1.resolve(A.cwd, n.cS.toPortablePath(e)); + return (await r.baseFs.statPromise(o)).isDirectory() + ? ((A.cwd = o), 0) + : (A.stderr.write('cd: not a directory\n'), 1); + }, + ], + [ + 'pwd', + async (e, t, r) => ( + r.stdout.write(n.cS.fromPortablePath(r.cwd) + '\n'), 0 + ), + ], + [':', async (e, t, r) => 0], + ['true', async (e, t, r) => 0], + ['false', async (e, t, r) => 1], + [ + 'exit', + async ([e, ...t], r, A) => + (A.exitCode = parseInt(null != e ? e : A.variables['?'], 10)), + ], + ['echo', async (e, t, r) => (r.stdout.write(e.join(' ') + '\n'), 0)], + [ + '__ysh_run_procedure', + async (e, t, r) => { + const A = r.procedures[e[0]]; + return await F(A, { + stdin: new S(r.stdin), + stdout: new S(r.stdout), + stderr: new S(r.stderr), + }).run(); + }, + ], + [ + '__ysh_set_redirects', + async (e, t, r) => { + let A = r.stdin, + o = r.stdout; + const i = r.stderr, + s = [], + c = []; + let g = 0; + for (; '--' !== e[g]; ) { + const A = e[g++], + o = Number(e[g++]), + i = g + o; + for (let o = g; o < i; ++g, ++o) + switch (A) { + case '<': + s.push(() => + t.baseFs.createReadStream( + n.y1.resolve(r.cwd, n.cS.toPortablePath(e[o])) + ) + ); + break; + case '<<<': + s.push(() => { + const t = new a.PassThrough(); + return ( + process.nextTick(() => { + t.write(e[o] + '\n'), t.end(); + }), + t + ); + }); + break; + case '<&': + s.push(() => M(Number(e[o]), K.Readable, r)); + break; + case '>': + case '>>': + { + const i = n.y1.resolve( + r.cwd, + n.cS.toPortablePath(e[o]) + ); + '/dev/null' === i + ? c.push( + new a.Writable({ + autoDestroy: !0, + emitClose: !0, + write(e, t, r) { + setImmediate(r); + }, + }) + ) + : c.push( + t.baseFs.createWriteStream( + i, + '>>' === A ? { flags: 'a' } : void 0 + ) + ); + } + break; + case '>&': + c.push(M(Number(e[o]), K.Writable, r)); + break; + default: + throw new Error( + `Assertion failed: Unsupported redirection type: "${A}"` + ); + } + } + if (s.length > 0) { + const e = new a.PassThrough(); + A = e; + const t = (r) => { + if (r === s.length) e.end(); + else { + const A = s[r](); + A.pipe(e, { end: !1 }), + A.on('end', () => { + t(r + 1); + }); + } + }; + t(0); + } + if (c.length > 0) { + const e = new a.PassThrough(); + o = e; + for (const t of c) e.pipe(t); + } + const l = await F(G(e.slice(g + 1), t, r), { + stdin: new S(A), + stdout: new S(o), + stderr: new S(i), + }).run(); + return ( + await Promise.all( + c.map( + (e) => + new Promise((t) => { + e.on('close', () => { + t(); + }), + e.end(); + }) + ) + ), + l + ); + }, + ], + ]); + async function L(e, t, r) { + const A = [], + n = new a.PassThrough(); + return ( + n.on('data', (e) => A.push(e)), + await W(e, t, R(r, { stdout: n })), + Buffer.concat(A) + .toString() + .replace(/[\r\n]+$/, '') + ); + } + async function P(e, t, r) { + const A = e.map(async (e) => { + const A = await Y(e.args, t, r); + return { name: e.name, value: A.join(' ') }; + }); + return (await Promise.all(A)).reduce( + (e, t) => ((e[t.name] = t.value), e), + {} + ); + } + function O(e) { + return e.match(/[^ \r\n\t]+/g) || []; + } + async function U(e, t, r, A, n = A) { + switch (e.name) { + case '$': + A(String(process.pid)); + break; + case '#': + A(String(t.args.length)); + break; + case '@': + if (e.quoted) for (const e of t.args) n(e); + else + for (const e of t.args) { + const t = O(e); + for (let e = 0; e < t.length - 1; ++e) n(t[e]); + A(t[t.length - 1]); + } + break; + case '*': + { + const r = t.args.join(' '); + if (e.quoted) A(r); + else for (const e of O(r)) n(e); + } + break; + case 'PPID': + A(String(process.ppid)); + break; + case 'RANDOM': + A(String(Math.floor(32768 * Math.random()))); + break; + default: { + const n = parseInt(e.name, 10); + if (Number.isFinite(n)) + if (n >= 0 && n < t.args.length) A(t.args[n]); + else { + if (!e.defaultValue) throw new c('Unbound argument #' + n); + A((await Y(e.defaultValue, t, r)).join(' ')); + } + else if ( + Object.prototype.hasOwnProperty.call(r.variables, e.name) + ) + A(r.variables[e.name]); + else if ( + Object.prototype.hasOwnProperty.call(r.environment, e.name) + ) + A(r.environment[e.name]); + else { + if (!e.defaultValue) + throw new c(`Unbound variable "${e.name}"`); + A((await Y(e.defaultValue, t, r)).join(' ')); + } + } + } + } + const T = { + addition: (e, t) => e + t, + subtraction: (e, t) => e - t, + multiplication: (e, t) => e * t, + division: (e, t) => Math.trunc(e / t), + }; + async function j(e, t, r) { + if ('number' === e.type) { + if (Number.isInteger(e.value)) return e.value; + throw new Error( + `Invalid number: "${e.value}", only integers are allowed` + ); + } + if ('variable' === e.type) { + const A = []; + await U({ ...e, quoted: !0 }, t, r, (e) => A.push(e)); + const n = Number(A.join(' ')); + return Number.isNaN(n) + ? j({ type: 'variable', name: A.join(' ') }, t, r) + : j({ type: 'number', value: n }, t, r); + } + return T[e.type](await j(e.left, t, r), await j(e.right, t, r)); + } + async function Y(e, t, r) { + const A = new Map(), + n = []; + let o = []; + const i = (e) => { + o.push(e); + }, + s = () => { + o.length > 0 && n.push(o.join('')), (o = []); + }, + a = (e) => { + i(e), s(); + }, + g = (e, t) => { + let r = A.get(e); + void 0 === r && A.set(e, (r = [])), r.push(t); + }; + for (const A of e) { + let e = !1; + switch (A.type) { + case 'redirection': + { + const e = await Y(A.args, t, r); + for (const t of e) g(A.subtype, t); + } + break; + case 'argument': + for (const n of A.segments) + switch (n.type) { + case 'text': + i(n.text); + break; + case 'glob': + i(n.pattern), (e = !0); + break; + case 'shell': + { + const e = await L(n.shell, t, r); + if (n.quoted) i(e); + else { + const t = O(e); + for (let e = 0; e < t.length - 1; ++e) a(t[e]); + i(t[t.length - 1]); + } + } + break; + case 'variable': + await U(n, t, r, i, a); + break; + case 'arithmetic': + i(String(await j(n.arithmetic, t, r))); + } + } + if ((s(), e)) { + const e = n.pop(); + if (void 0 === e) + throw new Error( + 'Assertion failed: Expected a glob pattern to have been set' + ); + const A = await t.glob.match(e, { cwd: r.cwd, baseFs: t.baseFs }); + if (0 === A.length) { + const t = m(e) + ? ". Note: Brace expansion of arbitrary strings isn't currently supported. For more details, please read this issue: https://github.com/yarnpkg/berry/issues/22" + : ''; + throw new c(`No matches found: "${e}"${t}`); + } + for (const e of A.sort()) a(e); + } + } + if (A.size > 0) { + const e = []; + for (const [t, r] of A.entries()) + e.splice(e.length, 0, t, String(r.length), ...r); + n.splice(0, 0, '__ysh_set_redirects', ...e, '--'); + } + return n; + } + function G(e, t, r) { + t.builtins.has(e[0]) || (e = ['command', ...e]); + const A = n.cS.fromPortablePath(r.cwd); + let o = r.environment; + void 0 !== o.PWD && (o = { ...o, PWD: A }); + const [i, ...s] = e; + if ('command' === i) + return (function (e, t, r, A) { + return (r) => { + const n = r[0] instanceof a.Transform ? 'pipe' : r[0], + o = r[1] instanceof a.Transform ? 'pipe' : r[1], + i = r[2] instanceof a.Transform ? 'pipe' : r[2], + s = D()(e, t, { ...A, stdio: [n, o, i] }); + return ( + 0 == v++ && process.on('SIGINT', b), + r[0] instanceof a.Transform && r[0].pipe(s.stdin), + r[1] instanceof a.Transform && + s.stdout.pipe(r[1], { end: !1 }), + r[2] instanceof a.Transform && + s.stderr.pipe(r[2], { end: !1 }), + { + stdin: s.stdin, + promise: new Promise((t) => { + s.on('error', (A) => { + switch ( + (0 == --v && process.off('SIGINT', b), A.code) + ) { + case 'ENOENT': + r[2].write(`command not found: ${e}\n`), t(127); + break; + case 'EACCES': + r[2].write(`permission denied: ${e}\n`), t(128); + break; + default: + r[2].write(`uncaught error: ${A.message}\n`), t(1); + } + }), + s.on('exit', (e) => { + 0 == --v && process.off('SIGINT', b), + t(null !== e ? e : 129); + }); + }), + } + ); + }; + })(s[0], s.slice(1), 0, { cwd: A, env: o }); + const c = t.builtins.get(i); + if (void 0 === c) + throw new Error( + `Assertion failed: A builtin should exist for "${i}"` + ); + return (function (e) { + return (t) => { + const r = 'pipe' === t[0] ? new a.PassThrough() : t[0]; + return { + stdin: r, + promise: Promise.resolve().then(() => + e({ stdin: r, stdout: t[1], stderr: t[2] }) + ), + }; + }; + })( + async ({ stdin: e, stdout: A, stderr: n }) => ( + (r.stdin = e), (r.stdout = A), (r.stderr = n), await c(s, t, r) + ) + ); + } + function H(e, t, r) { + return (A) => { + const n = new a.PassThrough(); + return { stdin: n, promise: W(e, t, R(r, { stdin: n })) }; + }; + } + function J(e, t, r) { + return (A) => ({ stdin: new a.PassThrough(), promise: W(e, t, r) }); + } + function q(e, t, r, A) { + if (0 === t.length) return e; + { + let n; + do { + n = String(Math.random()); + } while (Object.prototype.hasOwnProperty.call(A.procedures, n)); + return ( + (A.procedures = { ...A.procedures }), + (A.procedures[n] = e), + G([...t, '__ysh_run_procedure', n], r, A) + ); + } + } + async function z(e, t, r) { + let A; + const n = (e) => { + (A = e), (r.variables['?'] = String(e)); + }, + o = async (e) => { + try { + return await (async function (e, t, r) { + let A = e, + n = null, + o = null; + for (; A; ) { + const e = A.then ? { ...r } : r; + let i; + switch (A.type) { + case 'command': + { + const n = await Y(A.args, t, r), + o = await P(A.envs, t, r); + i = A.envs.length + ? G(n, t, R(e, { environment: o })) + : G(n, t, e); + } + break; + case 'subshell': + { + const n = await Y(A.args, t, r); + i = q(H(A.subshell, t, e), n, t, e); + } + break; + case 'group': + { + const n = await Y(A.args, t, r); + i = q(J(A.group, t, e), n, t, e); + } + break; + case 'envs': { + const n = await P(A.envs, t, r); + (e.environment = { ...e.environment, ...n }), + (i = G(['true'], t, e)); + } + } + if (void 0 === i) + throw new Error( + 'Assertion failed: An action should have been generated' + ); + if (null === n) + o = F(i, { + stdin: new S(e.stdin), + stdout: new S(e.stdout), + stderr: new S(e.stderr), + }); + else { + if (null === o) + throw new Error( + 'Assertion failed: The execution pipeline should have been setup' + ); + switch (n) { + case '|': + o = o.pipeTo(i, w.STDOUT); + break; + case '|&': + o = o.pipeTo(i, w.STDOUT | w.STDERR); + } + } + A.then + ? ((n = A.then.type), (A = A.then.chain)) + : (A = null); + } + if (null === o) + throw new Error( + 'Assertion failed: The execution pipeline should have been setup' + ); + return await o.run(); + })(e, t, r); + } catch (e) { + if (!(e instanceof c)) throw e; + return r.stderr.write(e.message + '\n'), 1; + } + }; + for (n(await o(e.chain)); e.then; ) { + if (null !== r.exitCode) return r.exitCode; + switch (e.then.type) { + case '&&': + 0 === A && n(await o(e.then.line.chain)); + break; + case '||': + 0 !== A && n(await o(e.then.line.chain)); + break; + default: + throw new Error( + `Assertion failed: Unsupported command type: "${e.then.type}"` + ); + } + e = e.then.line; + } + return A; + } + async function W(e, t, r) { + let A = 0; + for (const n of e) { + if (((A = await z(n, t, r)), null !== r.exitCode)) + return r.exitCode; + r.variables['?'] = String(A); + } + return A; + } + function V(e) { + switch (e.type) { + case 'variable': + return ( + '@' === e.name || + '#' === e.name || + '*' === e.name || + Number.isFinite(parseInt(e.name, 10)) || + ('defaultValue' in e && + !!e.defaultValue && + e.defaultValue.some((e) => X(e))) + ); + case 'arithmetic': + return (function e(t) { + switch (t.type) { + case 'variable': + return V(t); + case 'number': + return !1; + default: + return e(t.left) || e(t.right); + } + })(e.arithmetic); + case 'shell': + return _(e.shell); + default: + return !1; + } + } + function X(e) { + switch (e.type) { + case 'redirection': + return e.args.some((e) => X(e)); + case 'argument': + return e.segments.some((e) => V(e)); + default: + throw new Error( + `Assertion failed: Unsupported argument type: "${e.type}"` + ); + } + } + function _(e) { + return e.some((e) => { + for (; e; ) { + let t = e.chain; + for (; t; ) { + let e; + switch (t.type) { + case 'subshell': + e = _(t.subshell); + break; + case 'command': + e = + t.envs.some((e) => e.args.some((e) => X(e))) || + t.args.some((e) => X(e)); + } + if (e) return !0; + if (!t.then) break; + t = t.then.chain; + } + if (!e.then) break; + e = e.then.line; + } + return !1; + }); + } + async function Z( + e, + t = [], + { + baseFs: r = new o.S(), + builtins: s = {}, + cwd: c = n.cS.toPortablePath(process.cwd()), + env: g = process.env, + stdin: l = process.stdin, + stdout: u = process.stdout, + stderr: h = process.stderr, + variables: p = {}, + glob: d = A, + } = {} + ) { + const C = {}; + for (const [e, t] of Object.entries(g)) void 0 !== t && (C[e] = t); + const f = new Map(x); + for (const [e, t] of Object.entries(s)) f.set(e, t); + null === l && (l = new a.PassThrough()).end(); + const I = (0, i.parseShell)(e, d); + if (!_(I) && I.length > 0 && t.length > 0) { + let e = I[I.length - 1]; + for (; e.then; ) e = e.then.line; + let r = e.chain; + for (; r.then; ) r = r.then.chain; + 'command' === r.type && + (r.args = r.args.concat( + t.map((e) => ({ + type: 'argument', + segments: [{ type: 'text', text: e }], + })) + )); + } + return await W( + I, + { + args: t, + baseFs: r, + builtins: f, + initialStdin: l, + initialStdout: u, + initialStderr: h, + glob: d, + }, + { + cwd: c, + environment: C, + exitCode: null, + procedures: {}, + stdin: l, + stdout: u, + stderr: h, + variables: Object.assign({}, p, { '?': 0 }), + } + ); + } + }, + 45330: (e, t, r) => { + t.e = () => ({ + modules: new Map([ + ['@yarnpkg/cli', r(25413)], + ['@yarnpkg/core', r(53836)], + ['@yarnpkg/fslib', r(43896)], + ['@yarnpkg/libzip', r(65281)], + ['@yarnpkg/parsers', r(11640)], + ['@yarnpkg/shell', r(76756)], + ['clipanion', r(40822)], + ['semver', r(53887)], + ['yup', r(15966)], + ['@yarnpkg/plugin-essentials', r(34777)], + ['@yarnpkg/plugin-compat', r(44692)], + ['@yarnpkg/plugin-dlx', r(10189)], + ['@yarnpkg/plugin-file', r(68023)], + ['@yarnpkg/plugin-git', r(75641)], + ['@yarnpkg/plugin-github', r(68126)], + ['@yarnpkg/plugin-http', r(99148)], + ['@yarnpkg/plugin-init', r(64314)], + ['@yarnpkg/plugin-link', r(92994)], + ['@yarnpkg/plugin-node-modules', r(8375)], + ['@yarnpkg/plugin-npm', r(14224)], + ['@yarnpkg/plugin-npm-cli', r(8190)], + ['@yarnpkg/plugin-pack', r(49881)], + ['@yarnpkg/plugin-patch', r(29936)], + ['@yarnpkg/plugin-pnp', r(83228)], + ]), + plugins: new Set([ + '@yarnpkg/plugin-essentials', + '@yarnpkg/plugin-compat', + '@yarnpkg/plugin-dlx', + '@yarnpkg/plugin-file', + '@yarnpkg/plugin-git', + '@yarnpkg/plugin-github', + '@yarnpkg/plugin-http', + '@yarnpkg/plugin-init', + '@yarnpkg/plugin-link', + '@yarnpkg/plugin-node-modules', + '@yarnpkg/plugin-npm', + '@yarnpkg/plugin-npm-cli', + '@yarnpkg/plugin-pack', + '@yarnpkg/plugin-patch', + '@yarnpkg/plugin-pnp', + ]), + }); + }, + 29148: (e, t, r) => { + const A = r(74988), + n = /^(.*?)(\x1b\[[^m]+m|\x1b\]8;;.*?(\x1b\\|\u0007))/, + o = new A(); + e.exports = (e, t = 0, r = e.length) => { + if (t < 0 || r < 0) + throw new RangeError( + "Negative indices aren't supported by this implementation" + ); + const A = r - t; + let i = '', + s = 0, + a = 0; + for (; e.length > 0; ) { + const r = e.match(n) || [e, e, void 0]; + let c = o.splitGraphemes(r[1]); + const g = Math.min(t - s, c.length); + c = c.slice(g); + const l = Math.min(A - a, c.length); + (i += c.slice(0, l).join('')), + (s += g), + (a += l), + void 0 !== r[2] && (i += r[2]), + (e = e.slice(r[0].length)); + } + return i; + }; + }, + 72912: (e) => { + function t() { + return ( + (e.exports = t = + Object.assign || + function (e) { + for (var t = 1; t < arguments.length; t++) { + var r = arguments[t]; + for (var A in r) + Object.prototype.hasOwnProperty.call(r, A) && (e[A] = r[A]); + } + return e; + }), + t.apply(this, arguments) + ); + } + e.exports = t; + }, + 60087: (e) => { + e.exports = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + }, + 19228: (e, t, r) => { + var A = r(54694); + function n() { + if ('function' != typeof WeakMap) return null; + var e = new WeakMap(); + return ( + (n = function () { + return e; + }), + e + ); + } + e.exports = function (e) { + if (e && e.__esModule) return e; + if (null === e || ('object' !== A(e) && 'function' != typeof e)) + return { default: e }; + var t = n(); + if (t && t.has(e)) return t.get(e); + var r = {}, + o = Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var i in e) + if (Object.prototype.hasOwnProperty.call(e, i)) { + var s = o ? Object.getOwnPropertyDescriptor(e, i) : null; + s && (s.get || s.set) + ? Object.defineProperty(r, i, s) + : (r[i] = e[i]); + } + return (r.default = e), t && t.set(e, r), r; + }; + }, + 74943: (e) => { + e.exports = function (e, t) { + if (null == e) return {}; + var r, + A, + n = {}, + o = Object.keys(e); + for (A = 0; A < o.length; A++) + (r = o[A]), t.indexOf(r) >= 0 || (n[r] = e[r]); + return n; + }; + }, + 62407: (e) => { + e.exports = function (e, t) { + return t || (t = e.slice(0)), (e.raw = t), e; + }; + }, + 54694: (e) => { + function t(r) { + return ( + 'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator + ? (e.exports = t = function (e) { + return typeof e; + }) + : (e.exports = t = function (e) { + return e && + 'function' == typeof Symbol && + e.constructor === Symbol && + e !== Symbol.prototype + ? 'symbol' + : typeof e; + }), + t(r) + ); + } + e.exports = t; + }, + 96117: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(35747); + (t.FILE_SYSTEM_ADAPTER = { + lstat: A.lstat, + stat: A.stat, + lstatSync: A.lstatSync, + statSync: A.statSync, + readdir: A.readdir, + readdirSync: A.readdirSync, + }), + (t.createFileSystemAdapter = function (e) { + return void 0 === e + ? t.FILE_SYSTEM_ADAPTER + : Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e); + }); + }, + 79774: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const r = process.versions.node.split('.'), + A = parseInt(r[0], 10), + n = parseInt(r[1], 10), + o = A > 10, + i = 10 === A && n >= 10; + t.IS_SUPPORT_READDIR_WITH_FILE_TYPES = o || i; + }, + 85670: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(31020), + n = r(35516), + o = r(38844); + function i(e = {}) { + return e instanceof o.default ? e : new o.default(e); + } + (t.Settings = o.default), + (t.scandir = function (e, t, r) { + if ('function' == typeof t) return A.read(e, i(), t); + A.read(e, i(t), r); + }), + (t.scandirSync = function (e, t) { + const r = i(t); + return n.read(e, r); + }); + }, + 31020: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(53403), + n = r(69078), + o = r(79774), + i = r(65225); + function s(e, t, r) { + t.fs.readdir(e, { withFileTypes: !0 }, (A, o) => { + if (null !== A) return c(r, A); + const s = o.map((r) => ({ + dirent: r, + name: r.name, + path: `${e}${t.pathSegmentSeparator}${r.name}`, + })); + if (!t.followSymbolicLinks) return g(r, s); + const a = s.map((e) => + (function (e, t) { + return (r) => { + if (!e.dirent.isSymbolicLink()) return r(null, e); + t.fs.stat(e.path, (A, n) => + null !== A + ? t.throwErrorOnBrokenSymbolicLink + ? r(A) + : r(null, e) + : ((e.dirent = i.fs.createDirentFromStats(e.name, n)), + r(null, e)) + ); + }; + })(e, t) + ); + n(a, (e, t) => { + if (null !== e) return c(r, e); + g(r, t); + }); + }); + } + function a(e, t, r) { + t.fs.readdir(e, (o, s) => { + if (null !== o) return c(r, o); + const a = s.map((r) => `${e}${t.pathSegmentSeparator}${r}`), + l = a.map((e) => (r) => A.stat(e, t.fsStatSettings, r)); + n(l, (e, A) => { + if (null !== e) return c(r, e); + const n = []; + s.forEach((e, r) => { + const o = A[r], + s = { + name: e, + path: a[r], + dirent: i.fs.createDirentFromStats(e, o), + }; + t.stats && (s.stats = o), n.push(s); + }), + g(r, n); + }); + }); + } + function c(e, t) { + e(t); + } + function g(e, t) { + e(null, t); + } + (t.read = function (e, t, r) { + return !t.stats && o.IS_SUPPORT_READDIR_WITH_FILE_TYPES + ? s(e, t, r) + : a(e, t, r); + }), + (t.readdirWithFileTypes = s), + (t.readdir = a); + }, + 35516: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(53403), + n = r(79774), + o = r(65225); + function i(e, t) { + return t.fs.readdirSync(e, { withFileTypes: !0 }).map((r) => { + const A = { + dirent: r, + name: r.name, + path: `${e}${t.pathSegmentSeparator}${r.name}`, + }; + if (A.dirent.isSymbolicLink() && t.followSymbolicLinks) + try { + const e = t.fs.statSync(A.path); + A.dirent = o.fs.createDirentFromStats(A.name, e); + } catch (e) { + if (t.throwErrorOnBrokenSymbolicLink) throw e; + } + return A; + }); + } + function s(e, t) { + return t.fs.readdirSync(e).map((r) => { + const n = `${e}${t.pathSegmentSeparator}${r}`, + i = A.statSync(n, t.fsStatSettings), + s = { + name: r, + path: n, + dirent: o.fs.createDirentFromStats(r, i), + }; + return t.stats && (s.stats = i), s; + }); + } + (t.read = function (e, t) { + return !t.stats && n.IS_SUPPORT_READDIR_WITH_FILE_TYPES + ? i(e, t) + : s(e, t); + }), + (t.readdirWithFileTypes = i), + (t.readdir = s); + }, + 38844: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = r(53403), + o = r(96117); + t.default = class { + constructor(e = {}) { + (this._options = e), + (this.followSymbolicLinks = this._getValue( + this._options.followSymbolicLinks, + !1 + )), + (this.fs = o.createFileSystemAdapter(this._options.fs)), + (this.pathSegmentSeparator = this._getValue( + this._options.pathSegmentSeparator, + A.sep + )), + (this.stats = this._getValue(this._options.stats, !1)), + (this.throwErrorOnBrokenSymbolicLink = this._getValue( + this._options.throwErrorOnBrokenSymbolicLink, + !0 + )), + (this.fsStatSettings = new n.Settings({ + followSymbolicLink: this.followSymbolicLinks, + fs: this.fs, + throwErrorOnBrokenSymbolicLink: this + .throwErrorOnBrokenSymbolicLink, + })); + } + _getValue(e, t) { + return void 0 === e ? t : e; + } + }; + }, + 72156: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + class r { + constructor(e, t) { + (this.name = e), + (this.isBlockDevice = t.isBlockDevice.bind(t)), + (this.isCharacterDevice = t.isCharacterDevice.bind(t)), + (this.isDirectory = t.isDirectory.bind(t)), + (this.isFIFO = t.isFIFO.bind(t)), + (this.isFile = t.isFile.bind(t)), + (this.isSocket = t.isSocket.bind(t)), + (this.isSymbolicLink = t.isSymbolicLink.bind(t)); + } + } + t.createDirentFromStats = function (e, t) { + return new r(e, t); + }; + }, + 65225: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(72156); + t.fs = A; + }, + 71208: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(35747); + (t.FILE_SYSTEM_ADAPTER = { + lstat: A.lstat, + stat: A.stat, + lstatSync: A.lstatSync, + statSync: A.statSync, + }), + (t.createFileSystemAdapter = function (e) { + return void 0 === e + ? t.FILE_SYSTEM_ADAPTER + : Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e); + }); + }, + 53403: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(17790), + n = r(34846), + o = r(92687); + function i(e = {}) { + return e instanceof o.default ? e : new o.default(e); + } + (t.Settings = o.default), + (t.stat = function (e, t, r) { + if ('function' == typeof t) return A.read(e, i(), t); + A.read(e, i(t), r); + }), + (t.statSync = function (e, t) { + const r = i(t); + return n.read(e, r); + }); + }, + 17790: (e, t) => { + 'use strict'; + function r(e, t) { + e(t); + } + function A(e, t) { + e(null, t); + } + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.read = function (e, t, n) { + t.fs.lstat(e, (o, i) => + null !== o + ? r(n, o) + : i.isSymbolicLink() && t.followSymbolicLink + ? void t.fs.stat(e, (e, o) => { + if (null !== e) + return t.throwErrorOnBrokenSymbolicLink + ? r(n, e) + : A(n, i); + t.markSymbolicLink && (o.isSymbolicLink = () => !0), + A(n, o); + }) + : A(n, i) + ); + }); + }, + 34846: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.read = function (e, t) { + const r = t.fs.lstatSync(e); + if (!r.isSymbolicLink() || !t.followSymbolicLink) return r; + try { + const r = t.fs.statSync(e); + return t.markSymbolicLink && (r.isSymbolicLink = () => !0), r; + } catch (e) { + if (!t.throwErrorOnBrokenSymbolicLink) return r; + throw e; + } + }); + }, + 92687: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(71208); + t.default = class { + constructor(e = {}) { + (this._options = e), + (this.followSymbolicLink = this._getValue( + this._options.followSymbolicLink, + !0 + )), + (this.fs = A.createFileSystemAdapter(this._options.fs)), + (this.markSymbolicLink = this._getValue( + this._options.markSymbolicLink, + !1 + )), + (this.throwErrorOnBrokenSymbolicLink = this._getValue( + this._options.throwErrorOnBrokenSymbolicLink, + !0 + )); + } + _getValue(e, t) { + return void 0 === e ? t : e; + } + }; + }, + 72897: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(42369), + n = r(27696), + o = r(22111), + i = r(14954); + function s(e = {}) { + return e instanceof i.default ? e : new i.default(e); + } + (t.Settings = i.default), + (t.walk = function (e, t, r) { + if ('function' == typeof t) return new A.default(e, s()).read(t); + new A.default(e, s(t)).read(r); + }), + (t.walkSync = function (e, t) { + const r = s(t); + return new o.default(e, r).read(); + }), + (t.walkStream = function (e, t) { + const r = s(t); + return new n.default(e, r).read(); + }); + }, + 42369: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(98566); + t.default = class { + constructor(e, t) { + (this._root = e), + (this._settings = t), + (this._reader = new A.default(this._root, this._settings)), + (this._storage = new Set()); + } + read(e) { + this._reader.onError((t) => { + !(function (e, t) { + e(t); + })(e, t); + }), + this._reader.onEntry((e) => { + this._storage.add(e); + }), + this._reader.onEnd(() => { + !(function (e, t) { + e(null, t); + })(e, [...this._storage]); + }), + this._reader.read(); + } + }; + }, + 27696: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(92413), + n = r(98566); + t.default = class { + constructor(e, t) { + (this._root = e), + (this._settings = t), + (this._reader = new n.default(this._root, this._settings)), + (this._stream = new A.Readable({ + objectMode: !0, + read: () => {}, + destroy: this._reader.destroy.bind(this._reader), + })); + } + read() { + return ( + this._reader.onError((e) => { + this._stream.emit('error', e); + }), + this._reader.onEntry((e) => { + this._stream.push(e); + }), + this._reader.onEnd(() => { + this._stream.push(null); + }), + this._reader.read(), + this._stream + ); + } + }; + }, + 22111: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(97835); + t.default = class { + constructor(e, t) { + (this._root = e), + (this._settings = t), + (this._reader = new A.default(this._root, this._settings)); + } + read() { + return this._reader.read(); + } + }; + }, + 98566: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(28614), + n = r(85670), + o = r(98360), + i = r(10750), + s = r(75504); + class a extends s.default { + constructor(e, t) { + super(e, t), + (this._settings = t), + (this._scandir = n.scandir), + (this._emitter = new A.EventEmitter()), + (this._queue = o( + this._worker.bind(this), + this._settings.concurrency + )), + (this._isFatalError = !1), + (this._isDestroyed = !1), + (this._queue.drain = () => { + this._isFatalError || this._emitter.emit('end'); + }); + } + read() { + return ( + (this._isFatalError = !1), + (this._isDestroyed = !1), + setImmediate(() => { + this._pushToQueue(this._root, this._settings.basePath); + }), + this._emitter + ); + } + destroy() { + if (this._isDestroyed) + throw new Error('The reader is already destroyed'); + (this._isDestroyed = !0), this._queue.killAndDrain(); + } + onEntry(e) { + this._emitter.on('entry', e); + } + onError(e) { + this._emitter.once('error', e); + } + onEnd(e) { + this._emitter.once('end', e); + } + _pushToQueue(e, t) { + const r = { directory: e, base: t }; + this._queue.push(r, (e) => { + null !== e && this._handleError(e); + }); + } + _worker(e, t) { + this._scandir( + e.directory, + this._settings.fsScandirSettings, + (r, A) => { + if (null !== r) return t(r, void 0); + for (const t of A) this._handleEntry(t, e.base); + t(null, void 0); + } + ); + } + _handleError(e) { + i.isFatalError(this._settings, e) && + ((this._isFatalError = !0), + (this._isDestroyed = !0), + this._emitter.emit('error', e)); + } + _handleEntry(e, t) { + if (this._isDestroyed || this._isFatalError) return; + const r = e.path; + void 0 !== t && + (e.path = i.joinPathSegments( + t, + e.name, + this._settings.pathSegmentSeparator + )), + i.isAppliedFilter(this._settings.entryFilter, e) && + this._emitEntry(e), + e.dirent.isDirectory() && + i.isAppliedFilter(this._settings.deepFilter, e) && + this._pushToQueue(r, e.path); + } + _emitEntry(e) { + this._emitter.emit('entry', e); + } + } + t.default = a; + }, + 10750: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.isFatalError = function (e, t) { + return null === e.errorFilter || !e.errorFilter(t); + }), + (t.isAppliedFilter = function (e, t) { + return null === e || e(t); + }), + (t.replacePathSegmentSeparator = function (e, t) { + return e.split(/[\\/]/).join(t); + }), + (t.joinPathSegments = function (e, t, r) { + return '' === e ? t : e + r + t; + }); + }, + 75504: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(10750); + t.default = class { + constructor(e, t) { + (this._root = e), + (this._settings = t), + (this._root = A.replacePathSegmentSeparator( + e, + t.pathSegmentSeparator + )); + } + }; + }, + 97835: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85670), + n = r(10750), + o = r(75504); + class i extends o.default { + constructor() { + super(...arguments), + (this._scandir = A.scandirSync), + (this._storage = new Set()), + (this._queue = new Set()); + } + read() { + return ( + this._pushToQueue(this._root, this._settings.basePath), + this._handleQueue(), + [...this._storage] + ); + } + _pushToQueue(e, t) { + this._queue.add({ directory: e, base: t }); + } + _handleQueue() { + for (const e of this._queue.values()) + this._handleDirectory(e.directory, e.base); + } + _handleDirectory(e, t) { + try { + const r = this._scandir(e, this._settings.fsScandirSettings); + for (const e of r) this._handleEntry(e, t); + } catch (e) { + this._handleError(e); + } + } + _handleError(e) { + if (n.isFatalError(this._settings, e)) throw e; + } + _handleEntry(e, t) { + const r = e.path; + void 0 !== t && + (e.path = n.joinPathSegments( + t, + e.name, + this._settings.pathSegmentSeparator + )), + n.isAppliedFilter(this._settings.entryFilter, e) && + this._pushToStorage(e), + e.dirent.isDirectory() && + n.isAppliedFilter(this._settings.deepFilter, e) && + this._pushToQueue(r, e.path); + } + _pushToStorage(e) { + this._storage.add(e); + } + } + t.default = i; + }, + 14954: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = r(85670); + t.default = class { + constructor(e = {}) { + (this._options = e), + (this.basePath = this._getValue(this._options.basePath, void 0)), + (this.concurrency = this._getValue( + this._options.concurrency, + 1 / 0 + )), + (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, + A.sep + )), + (this.fsScandirSettings = new n.Settings({ + followSymbolicLinks: this._options.followSymbolicLinks, + fs: this._options.fs, + pathSegmentSeparator: this._options.pathSegmentSeparator, + stats: this._options.stats, + throwErrorOnBrokenSymbolicLink: this._options + .throwErrorOnBrokenSymbolicLink, + })); + } + _getValue(e, t) { + return void 0 === e ? t : e; + } + }; + }, + 7966: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const r = [ + 'Int8Array', + 'Uint8Array', + 'Uint8ClampedArray', + 'Int16Array', + 'Uint16Array', + 'Int32Array', + 'Uint32Array', + 'Float32Array', + 'Float64Array', + 'BigInt64Array', + 'BigUint64Array', + ]; + const A = [ + 'Function', + 'Generator', + 'AsyncGenerator', + 'GeneratorFunction', + 'AsyncGeneratorFunction', + 'AsyncFunction', + 'Observable', + 'Array', + 'Buffer', + 'Object', + 'RegExp', + 'Date', + 'Error', + 'Map', + 'Set', + 'WeakMap', + 'WeakSet', + 'ArrayBuffer', + 'SharedArrayBuffer', + 'DataView', + 'Promise', + 'URL', + 'HTMLElement', + ...r, + ]; + const n = [ + 'null', + 'undefined', + 'string', + 'number', + 'bigint', + 'boolean', + 'symbol', + ]; + function o(e) { + return (t) => typeof t === e; + } + const { toString: i } = Object.prototype, + s = (e) => { + const t = i.call(e).slice(8, -1); + return /HTML\w+Element/.test(t) && c.domElement(e) + ? 'HTMLElement' + : ((r = t), A.includes(r) ? t : void 0); + var r; + }, + a = (e) => (t) => s(t) === e; + function c(e) { + if (null === e) return 'null'; + switch (typeof e) { + 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'; + } + if (c.observable(e)) return 'Observable'; + if (c.array(e)) return 'Array'; + if (c.buffer(e)) return 'Buffer'; + const t = s(e); + if (t) return t; + if ( + e instanceof String || + e instanceof Boolean || + e instanceof Number + ) + throw new TypeError( + "Please don't use object wrappers for primitive types" + ); + return 'Object'; + } + (c.undefined = o('undefined')), (c.string = o('string')); + const g = o('number'); + (c.number = (e) => g(e) && !c.nan(e)), + (c.bigint = o('bigint')), + (c.function_ = o('function')), + (c.null_ = (e) => null === e), + (c.class_ = (e) => + c.function_(e) && e.toString().startsWith('class ')), + (c.boolean = (e) => !0 === e || !1 === e), + (c.symbol = o('symbol')), + (c.numericString = (e) => + c.string(e) && + !c.emptyStringOrWhitespace(e) && + !Number.isNaN(Number(e))), + (c.array = (e, t) => + !!Array.isArray(e) && (!c.function_(t) || e.every(t))), + (c.buffer = (e) => { + var t, r, A, n; + return ( + null !== + (n = + null === + (A = + null === + (r = + null === (t = e) || void 0 === t + ? void 0 + : t.constructor) || void 0 === r + ? void 0 + : r.isBuffer) || void 0 === A + ? void 0 + : A.call(r, e)) && + void 0 !== n && + n + ); + }), + (c.nullOrUndefined = (e) => c.null_(e) || c.undefined(e)), + (c.object = (e) => + !c.null_(e) && ('object' == typeof e || c.function_(e))), + (c.iterable = (e) => { + var t; + return c.function_( + null === (t = e) || void 0 === t ? void 0 : t[Symbol.iterator] + ); + }), + (c.asyncIterable = (e) => { + var t; + return c.function_( + null === (t = e) || void 0 === t + ? void 0 + : t[Symbol.asyncIterator] + ); + }), + (c.generator = (e) => + c.iterable(e) && c.function_(e.next) && c.function_(e.throw)), + (c.asyncGenerator = (e) => + c.asyncIterable(e) && c.function_(e.next) && c.function_(e.throw)), + (c.nativePromise = (e) => a('Promise')(e)); + (c.promise = (e) => + c.nativePromise(e) || + ((e) => { + var t, r; + return ( + c.function_(null === (t = e) || void 0 === t ? void 0 : t.then) && + c.function_(null === (r = e) || void 0 === r ? void 0 : r.catch) + ); + })(e)), + (c.generatorFunction = a('GeneratorFunction')), + (c.asyncGeneratorFunction = (e) => 'AsyncGeneratorFunction' === s(e)), + (c.asyncFunction = (e) => 'AsyncFunction' === s(e)), + (c.boundFunction = (e) => + c.function_(e) && !e.hasOwnProperty('prototype')), + (c.regExp = a('RegExp')), + (c.date = a('Date')), + (c.error = a('Error')), + (c.map = (e) => a('Map')(e)), + (c.set = (e) => a('Set')(e)), + (c.weakMap = (e) => a('WeakMap')(e)), + (c.weakSet = (e) => a('WeakSet')(e)), + (c.int8Array = a('Int8Array')), + (c.uint8Array = a('Uint8Array')), + (c.uint8ClampedArray = a('Uint8ClampedArray')), + (c.int16Array = a('Int16Array')), + (c.uint16Array = a('Uint16Array')), + (c.int32Array = a('Int32Array')), + (c.uint32Array = a('Uint32Array')), + (c.float32Array = a('Float32Array')), + (c.float64Array = a('Float64Array')), + (c.bigInt64Array = a('BigInt64Array')), + (c.bigUint64Array = a('BigUint64Array')), + (c.arrayBuffer = a('ArrayBuffer')), + (c.sharedArrayBuffer = a('SharedArrayBuffer')), + (c.dataView = a('DataView')), + (c.directInstanceOf = (e, t) => + Object.getPrototypeOf(e) === t.prototype), + (c.urlInstance = (e) => a('URL')(e)), + (c.urlString = (e) => { + if (!c.string(e)) return !1; + try { + return new URL(e), !0; + } catch (e) { + return !1; + } + }), + (c.truthy = (e) => Boolean(e)), + (c.falsy = (e) => !e), + (c.nan = (e) => Number.isNaN(e)), + (c.primitive = (e) => { + return c.null_(e) || ((t = typeof e), n.includes(t)); + var t; + }), + (c.integer = (e) => Number.isInteger(e)), + (c.safeInteger = (e) => Number.isSafeInteger(e)), + (c.plainObject = (e) => { + if ('[object Object]' !== i.call(e)) return !1; + const t = Object.getPrototypeOf(e); + return null === t || t === Object.getPrototypeOf({}); + }), + (c.typedArray = (e) => { + return (t = s(e)), r.includes(t); + var t; + }); + (c.arrayLike = (e) => + !c.nullOrUndefined(e) && + !c.function_(e) && + ((e) => c.safeInteger(e) && e >= 0)(e.length)), + (c.inRange = (e, t) => { + if (c.number(t)) return e >= Math.min(0, t) && e <= Math.max(t, 0); + if (c.array(t) && 2 === t.length) + return e >= Math.min(...t) && e <= Math.max(...t); + throw new TypeError('Invalid range: ' + JSON.stringify(t)); + }); + const l = [ + 'innerHTML', + 'ownerDocument', + 'style', + 'attributes', + 'nodeValue', + ]; + (c.domElement = (e) => + c.object(e) && + 1 === e.nodeType && + c.string(e.nodeName) && + !c.plainObject(e) && + l.every((t) => t in e)), + (c.observable = (e) => { + var t, r, A, n; + return ( + !!e && + (e === + (null === (r = (t = e)[Symbol.observable]) || void 0 === r + ? void 0 + : r.call(t)) || + e === + (null === (n = (A = e)['@@observable']) || void 0 === n + ? void 0 + : n.call(A))) + ); + }), + (c.nodeStream = (e) => + c.object(e) && c.function_(e.pipe) && !c.observable(e)), + (c.infinite = (e) => e === 1 / 0 || e === -1 / 0); + const u = (e) => (t) => c.integer(t) && Math.abs(t % 2) === e; + (c.evenInteger = u(0)), + (c.oddInteger = u(1)), + (c.emptyArray = (e) => c.array(e) && 0 === e.length), + (c.nonEmptyArray = (e) => c.array(e) && e.length > 0), + (c.emptyString = (e) => c.string(e) && 0 === e.length), + (c.nonEmptyString = (e) => c.string(e) && e.length > 0); + (c.emptyStringOrWhitespace = (e) => + c.emptyString(e) || ((e) => c.string(e) && !/\S/.test(e))(e)), + (c.emptyObject = (e) => + c.object(e) && + !c.map(e) && + !c.set(e) && + 0 === Object.keys(e).length), + (c.nonEmptyObject = (e) => + c.object(e) && !c.map(e) && !c.set(e) && Object.keys(e).length > 0), + (c.emptySet = (e) => c.set(e) && 0 === e.size), + (c.nonEmptySet = (e) => c.set(e) && e.size > 0), + (c.emptyMap = (e) => c.map(e) && 0 === e.size), + (c.nonEmptyMap = (e) => c.map(e) && e.size > 0); + const h = (e, t, r) => { + if (!c.function_(t)) + throw new TypeError('Invalid predicate: ' + JSON.stringify(t)); + if (0 === r.length) throw new TypeError('Invalid number of values'); + return e.call(r, t); + }; + (c.any = (e, ...t) => + (c.array(e) ? e : [e]).some((e) => h(Array.prototype.some, e, t))), + (c.all = (e, ...t) => h(Array.prototype.every, e, t)); + const p = (e, t, r) => { + if (!e) + throw new TypeError( + `Expected value which is \`${t}\`, received value of type \`${c( + r + )}\`.` + ); + }; + (t.assert = { + undefined: (e) => p(c.undefined(e), 'undefined', e), + string: (e) => p(c.string(e), 'string', e), + number: (e) => p(c.number(e), 'number', e), + bigint: (e) => p(c.bigint(e), 'bigint', e), + function_: (e) => p(c.function_(e), 'Function', e), + null_: (e) => p(c.null_(e), 'null', e), + class_: (e) => p(c.class_(e), 'Class', e), + boolean: (e) => p(c.boolean(e), 'boolean', e), + symbol: (e) => p(c.symbol(e), 'symbol', e), + numericString: (e) => + p(c.numericString(e), 'string with a number', e), + array: (e, t) => { + p(c.array(e), 'Array', e), t && e.forEach(t); + }, + buffer: (e) => p(c.buffer(e), 'Buffer', e), + nullOrUndefined: (e) => + p(c.nullOrUndefined(e), 'null or undefined', e), + object: (e) => p(c.object(e), 'Object', e), + iterable: (e) => p(c.iterable(e), 'Iterable', e), + asyncIterable: (e) => p(c.asyncIterable(e), 'AsyncIterable', e), + generator: (e) => p(c.generator(e), 'Generator', e), + asyncGenerator: (e) => p(c.asyncGenerator(e), 'AsyncGenerator', e), + nativePromise: (e) => p(c.nativePromise(e), 'native Promise', e), + promise: (e) => p(c.promise(e), 'Promise', e), + generatorFunction: (e) => + p(c.generatorFunction(e), 'GeneratorFunction', e), + asyncGeneratorFunction: (e) => + p(c.asyncGeneratorFunction(e), 'AsyncGeneratorFunction', e), + asyncFunction: (e) => p(c.asyncFunction(e), 'AsyncFunction', e), + boundFunction: (e) => p(c.boundFunction(e), 'Function', e), + regExp: (e) => p(c.regExp(e), 'RegExp', e), + date: (e) => p(c.date(e), 'Date', e), + error: (e) => p(c.error(e), 'Error', e), + map: (e) => p(c.map(e), 'Map', e), + set: (e) => p(c.set(e), 'Set', e), + weakMap: (e) => p(c.weakMap(e), 'WeakMap', e), + weakSet: (e) => p(c.weakSet(e), 'WeakSet', e), + int8Array: (e) => p(c.int8Array(e), 'Int8Array', e), + uint8Array: (e) => p(c.uint8Array(e), 'Uint8Array', e), + uint8ClampedArray: (e) => + p(c.uint8ClampedArray(e), 'Uint8ClampedArray', e), + int16Array: (e) => p(c.int16Array(e), 'Int16Array', e), + uint16Array: (e) => p(c.uint16Array(e), 'Uint16Array', e), + int32Array: (e) => p(c.int32Array(e), 'Int32Array', e), + uint32Array: (e) => p(c.uint32Array(e), 'Uint32Array', e), + float32Array: (e) => p(c.float32Array(e), 'Float32Array', e), + float64Array: (e) => p(c.float64Array(e), 'Float64Array', e), + bigInt64Array: (e) => p(c.bigInt64Array(e), 'BigInt64Array', e), + bigUint64Array: (e) => p(c.bigUint64Array(e), 'BigUint64Array', e), + arrayBuffer: (e) => p(c.arrayBuffer(e), 'ArrayBuffer', e), + sharedArrayBuffer: (e) => + p(c.sharedArrayBuffer(e), 'SharedArrayBuffer', e), + dataView: (e) => p(c.dataView(e), 'DataView', e), + urlInstance: (e) => p(c.urlInstance(e), 'URL', e), + urlString: (e) => p(c.urlString(e), 'string with a URL', e), + truthy: (e) => p(c.truthy(e), 'truthy', e), + falsy: (e) => p(c.falsy(e), 'falsy', e), + nan: (e) => p(c.nan(e), 'NaN', e), + primitive: (e) => p(c.primitive(e), 'primitive', e), + integer: (e) => p(c.integer(e), 'integer', e), + safeInteger: (e) => p(c.safeInteger(e), 'integer', e), + plainObject: (e) => p(c.plainObject(e), 'plain object', e), + typedArray: (e) => p(c.typedArray(e), 'TypedArray', e), + arrayLike: (e) => p(c.arrayLike(e), 'array-like', e), + domElement: (e) => p(c.domElement(e), 'HTMLElement', e), + observable: (e) => p(c.observable(e), 'Observable', e), + nodeStream: (e) => p(c.nodeStream(e), 'Node.js Stream', e), + infinite: (e) => p(c.infinite(e), 'infinite number', e), + emptyArray: (e) => p(c.emptyArray(e), 'empty array', e), + nonEmptyArray: (e) => p(c.nonEmptyArray(e), 'non-empty array', e), + emptyString: (e) => p(c.emptyString(e), 'empty string', e), + nonEmptyString: (e) => p(c.nonEmptyString(e), 'non-empty string', e), + emptyStringOrWhitespace: (e) => + p(c.emptyStringOrWhitespace(e), 'empty string or whitespace', e), + emptyObject: (e) => p(c.emptyObject(e), 'empty object', e), + nonEmptyObject: (e) => p(c.nonEmptyObject(e), 'non-empty object', e), + emptySet: (e) => p(c.emptySet(e), 'empty set', e), + nonEmptySet: (e) => p(c.nonEmptySet(e), 'non-empty set', e), + emptyMap: (e) => p(c.emptyMap(e), 'empty map', e), + nonEmptyMap: (e) => p(c.nonEmptyMap(e), 'non-empty map', e), + evenInteger: (e) => p(c.evenInteger(e), 'even integer', e), + oddInteger: (e) => p(c.oddInteger(e), 'odd integer', e), + directInstanceOf: (e, t) => p(c.directInstanceOf(e, t), 'T', e), + inRange: (e, t) => p(c.inRange(e, t), 'in range', e), + any: (e, ...t) => + p(c.any(e, ...t), 'predicate returns truthy for any value', t), + all: (e, ...t) => + p(c.all(e, ...t), 'predicate returns truthy for all values', t), + }), + Object.defineProperties(c, { + class: { value: c.class_ }, + function: { value: c.function_ }, + null: { value: c.null_ }, + }), + Object.defineProperties(t.assert, { + class: { value: t.assert.class_ }, + function: { value: t.assert.function_ }, + null: { value: t.assert.null_ }, + }), + (t.default = c), + (e.exports = c), + (e.exports.default = c), + (e.exports.assert = t.assert); + }, + 98298: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(93121), + n = Number(process.versions.node.split('.')[0]), + o = (e) => { + const t = { + start: Date.now(), + socket: void 0, + lookup: void 0, + connect: void 0, + secureConnect: void 0, + upload: void 0, + response: void 0, + end: void 0, + error: void 0, + abort: void 0, + phases: { + wait: void 0, + dns: void 0, + tcp: void 0, + tls: void 0, + request: void 0, + firstByte: void 0, + download: void 0, + total: void 0, + }, + }; + e.timings = t; + const r = (e) => { + const r = e.emit.bind(e); + e.emit = (A, ...n) => ( + 'error' === A && + ((t.error = Date.now()), + (t.phases.total = t.error - t.start), + (e.emit = r)), + r(A, ...n) + ); + }; + r(e), + e.prependOnceListener('abort', () => { + (t.abort = Date.now()), + (!t.response || n >= 13) && + (t.phases.total = Date.now() - t.start); + }); + const o = (e) => { + (t.socket = Date.now()), (t.phases.wait = t.socket - t.start); + const r = () => { + (t.lookup = Date.now()), (t.phases.dns = t.lookup - t.socket); + }; + e.prependOnceListener('lookup', r), + A.default(e, { + connect: () => { + (t.connect = Date.now()), + void 0 === t.lookup && + (e.removeListener('lookup', r), + (t.lookup = t.connect), + (t.phases.dns = t.lookup - t.socket)), + (t.phases.tcp = t.connect - t.lookup); + }, + secureConnect: () => { + (t.secureConnect = Date.now()), + (t.phases.tls = t.secureConnect - t.connect); + }, + }); + }; + e.socket ? o(e.socket) : e.prependOnceListener('socket', o); + const i = () => { + var e; + (t.upload = Date.now()), + (t.phases.request = + t.upload - (null != (e = t.secureConnect) ? e : t.connect)); + }; + return ( + ( + 'boolean' == typeof e.writableFinished + ? !e.writableFinished + : !e.finished || + 0 !== e.outputSize || + (e.socket && 0 !== e.socket.writableLength) + ) + ? e.prependOnceListener('finish', i) + : i(), + e.prependOnceListener('response', (e) => { + (t.response = Date.now()), + (t.phases.firstByte = t.response - t.upload), + (e.timings = t), + r(e), + e.prependOnceListener('end', () => { + (t.end = Date.now()), + (t.phases.download = t.end - t.response), + (t.phases.total = t.end - t.start); + }); + }), + t + ); + }; + (t.default = o), (e.exports = o), (e.exports.default = o); + }, + 58069: (e, t, r) => { + 'use strict'; + l.ifExists = function (e, t, r) { + return l(e, t, r).catch(() => {}); + }; + const A = r(31669), + n = r(46227), + o = r(85622), + i = r(97369), + s = /^#!\s*(?:\/usr\/bin\/env)?\s*([^ \t]+)(.*)$/, + a = { createPwshFile: !0, createCmdFile: i(), fs: r(35747) }, + c = new Map([ + ['.js', 'node'], + ['.cmd', 'cmd'], + ['.bat', 'cmd'], + ['.ps1', 'pwsh'], + ['.sh', 'sh'], + ]); + function g(e) { + const t = { ...a, ...e }, + r = t.fs; + return ( + (t.fs_ = { + chmod: r.chmod ? A.promisify(r.chmod) : async () => {}, + stat: A.promisify(r.stat), + unlink: A.promisify(r.unlink), + readFile: A.promisify(r.readFile), + writeFile: A.promisify(r.writeFile), + }), + t + ); + } + async function l(e, t, r) { + const A = g(r); + await A.fs_.stat(e), + await (async function (e, t, r) { + const A = await (async function (e, t) { + const r = await t.fs_.readFile(e, 'utf8'), + A = r.trim().split(/\r*\n/)[0].match(s); + if (!A) { + const t = o.extname(e).toLowerCase(); + return { program: c.get(t) || null, additionalArgs: '' }; + } + return { program: A[1], additionalArgs: A[2] }; + })(e, r); + return ( + await (function (e, t) { + return n(o.dirname(e), { fs: t.fs }); + })(t, r), + (function (e, t, r, A) { + const n = g(A), + o = [{ generator: h, extension: '' }]; + n.createCmdFile && + o.push({ generator: u, extension: '.cmd' }); + n.createPwshFile && + o.push({ generator: p, extension: '.ps1' }); + return Promise.all( + o.map((A) => + (async function (e, t, r, A, n) { + const o = n.preserveSymlinks + ? '--preserve-symlinks' + : '', + i = [r.additionalArgs, o].filter((e) => e).join(' '); + return ( + (n = Object.assign({}, n, { + prog: r.program, + args: i, + })), + await (function (e, t) { + return (function (e, t) { + return t.fs_.unlink(e).catch(() => {}); + })(e, t); + })(t, n), + await n.fs_.writeFile(t, A(e, t, n), 'utf8'), + (function (e, t) { + return (function (e, t) { + return t.fs_.chmod(e, 493); + })(e, t); + })(t, n) + ); + })(e, t + A.extension, r, A.generator, n) + ) + ); + })(e, t, A, r) + ); + })(e, t, A); + } + function u(e, t, r) { + let A = o.relative(o.dirname(t), e).split('/').join('\\'); + const n = o.isAbsolute(A) ? `"${A}"` : `"%~dp0\\${A}"`; + let i, + s = r.prog, + a = r.args || ''; + const c = d(r.nodePath).win32; + s + ? ((i = `"%~dp0\\${s}.exe"`), (A = n)) + : ((s = n), (a = ''), (A = '')); + let g = r.progArgs ? r.progArgs.join(' ') + ' ' : '', + l = c ? `@SET NODE_PATH=${c}\r\n` : ''; + return ( + (l += i + ? `@IF EXIST ${i} (\r\n ${i} ${a} ${A} ${g}%*\r\n) ELSE (\r\n @SETLOCAL\r\n @SET PATHEXT=%PATHEXT:;.JS;=;%\r\n ${s} ${a} ${A} ${g}%*\r\n)` + : `@${s} ${a} ${A} ${g}%*\r\n`), + l + ); + } + function h(e, t, r) { + let A, + n = o.relative(o.dirname(t), e), + i = r.prog && r.prog.split('\\').join('/'); + n = n.split('\\').join('/'); + const s = o.isAbsolute(n) ? `"${n}"` : `"$basedir/${n}"`; + let a = r.args || ''; + const c = d(r.nodePath).posix; + i + ? ((A = `"$basedir/${r.prog}"`), (n = s)) + : ((i = s), (a = ''), (n = '')); + let g = r.progArgs ? r.progArgs.join(' ') + ' ' : '', + l = '#!/bin/sh\n'; + l += + 'basedir=$(dirname "$(echo "$0" | sed -e \'s,\\\\,/,g\')")\n\ncase `uname` in\n *CYGWIN*) basedir=`cygpath -w "$basedir"`;;\nesac\n\n'; + const u = r.nodePath ? `export NODE_PATH="${c}"\n` : ''; + return ( + (l += A + ? u + + `if [ -x ${A} ]; then\n` + + ` exec ${A} ${a} ${n} ${g}"$@"\nelse \n` + + ` exec ${i} ${a} ${n} ${g}"$@"\nfi\n` + : `${u}${i} ${a} ${n} ${g}"$@"\nexit $?\n`), + l + ); + } + function p(e, t, r) { + let A = o.relative(o.dirname(t), e); + const n = r.prog && r.prog.split('\\').join('/'); + let i, + s = n && `"${n}$exe"`; + A = A.split('\\').join('/'); + const a = o.isAbsolute(A) ? `"${A}"` : `"$basedir/${A}"`; + let c = r.args || '', + g = d(r.nodePath); + const l = g.win32, + u = g.posix; + s + ? ((i = `"$basedir/${r.prog}$exe"`), (A = a)) + : ((s = a), (c = ''), (A = '')); + let h = r.progArgs ? r.progArgs.join(' ') + ' ' : '', + p = + '#!/usr/bin/env pwsh\n$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent\n\n$exe=""\n' + + (r.nodePath + ? `$env_node_path=$env:NODE_PATH\n$env:NODE_PATH="${l}"\n` + : '') + + 'if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {\n # Fix case when both the Windows and Linux builds of Node\n # are installed in the same directory\n $exe=".exe"\n}'; + return ( + r.nodePath && (p = p + ' else {\n' + ` $env:NODE_PATH="${u}"\n}`), + (p += '\n'), + (p = i + ? p + + '$ret=0\n' + + `if (Test-Path ${i}) {\n # Support pipeline input\n if ($MyInvocation.ExpectingInput) {\n` + + ` $input | & ${i} ${c} ${A} ${h}$args\n } else {\n` + + ` & ${i} ${c} ${A} ${h}$args\n }\n $ret=$LASTEXITCODE\n} else {\n # Support pipeline input\n if ($MyInvocation.ExpectingInput) {\n` + + ` $input | & ${s} ${c} ${A} ${h}$args\n } else {\n` + + ` & ${s} ${c} ${A} ${h}$args\n }\n $ret=$LASTEXITCODE\n}\n` + + (r.nodePath ? '$env:NODE_PATH=$env_node_path\n' : '') + + 'exit $ret\n' + : p + + '# Support pipeline input\nif ($MyInvocation.ExpectingInput) {\n' + + ` $input | & ${s} ${c} ${A} ${h}$args\n} else {\n` + + ` & ${s} ${c} ${A} ${h}$args\n}\n` + + (r.nodePath ? '$env:NODE_PATH=$env_node_path\n' : '') + + 'exit $LASTEXITCODE\n'), + p + ); + } + function d(e) { + if (!e) return { win32: '', posix: '' }; + let t = 'string' == typeof e ? e.split(o.delimiter) : Array.from(e), + r = {}; + for (let e = 0; e < t.length; e++) { + const A = t[e].split('/').join('\\'), + n = i() + ? t[e] + .split('\\') + .join('/') + .replace( + /^([^:\\/]*):/, + (e, t) => '/mnt/' + t.toLowerCase() + ) + : t[e]; + (r.win32 = r.win32 ? `${r.win32};${A}` : A), + (r.posix = r.posix ? `${r.posix}:${n}` : n), + (r[e] = { win32: A, posix: n }); + } + return r; + } + e.exports = l; + }, + 97991: (e, t, r) => { + 'use strict'; + const A = /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g, + n = () => { + const e = { enabled: !0, visible: !0, styles: {}, keys: {} }; + 'FORCE_COLOR' in process.env && + (e.enabled = '0' !== process.env.FORCE_COLOR); + const t = (e, t, r) => + 'function' == typeof e ? e(t) : e.wrap(t, r), + n = (r, A) => { + if ('' === r || null == r) return ''; + if (!1 === e.enabled) return r; + if (!1 === e.visible) return ''; + let n = '' + r, + o = n.includes('\n'), + i = A.length; + for ( + i > 0 && + A.includes('unstyle') && + (A = [...new Set(['unstyle', ...A])].reverse()); + i-- > 0; + + ) + n = t(e.styles[A[i]], n, o); + return n; + }, + o = (t, r, A) => { + (e.styles[t] = ((e) => { + let t = (e.open = `[${e.codes[0]}m`), + r = (e.close = `[${e.codes[1]}m`), + A = (e.regex = new RegExp(`\\u001b\\[${e.codes[1]}m`, 'g')); + return ( + (e.wrap = (e, n) => { + e.includes(r) && (e = e.replace(A, r + t)); + let o = t + e + r; + return n ? o.replace(/\r*\n/g, `${r}$&${t}`) : o; + }), + e + ); + })({ name: t, codes: r })), + (e.keys[A] || (e.keys[A] = [])).push(t), + Reflect.defineProperty(e, t, { + configurable: !0, + enumerable: !0, + set(r) { + e.alias(t, r); + }, + get() { + let r = (e) => n(e, r.stack); + return ( + Reflect.setPrototypeOf(r, e), + (r.stack = this.stack ? this.stack.concat(t) : [t]), + r + ); + }, + }); + }; + return ( + o('reset', [0, 0], 'modifier'), + o('bold', [1, 22], 'modifier'), + o('dim', [2, 22], 'modifier'), + o('italic', [3, 23], 'modifier'), + o('underline', [4, 24], 'modifier'), + o('inverse', [7, 27], 'modifier'), + o('hidden', [8, 28], 'modifier'), + o('strikethrough', [9, 29], 'modifier'), + o('black', [30, 39], 'color'), + o('red', [31, 39], 'color'), + o('green', [32, 39], 'color'), + o('yellow', [33, 39], 'color'), + o('blue', [34, 39], 'color'), + o('magenta', [35, 39], 'color'), + o('cyan', [36, 39], 'color'), + o('white', [37, 39], 'color'), + o('gray', [90, 39], 'color'), + o('grey', [90, 39], 'color'), + o('bgBlack', [40, 49], 'bg'), + o('bgRed', [41, 49], 'bg'), + o('bgGreen', [42, 49], 'bg'), + o('bgYellow', [43, 49], 'bg'), + o('bgBlue', [44, 49], 'bg'), + o('bgMagenta', [45, 49], 'bg'), + o('bgCyan', [46, 49], 'bg'), + o('bgWhite', [47, 49], 'bg'), + o('blackBright', [90, 39], 'bright'), + o('redBright', [91, 39], 'bright'), + o('greenBright', [92, 39], 'bright'), + o('yellowBright', [93, 39], 'bright'), + o('blueBright', [94, 39], 'bright'), + o('magentaBright', [95, 39], 'bright'), + o('cyanBright', [96, 39], 'bright'), + o('whiteBright', [97, 39], 'bright'), + o('bgBlackBright', [100, 49], 'bgBright'), + o('bgRedBright', [101, 49], 'bgBright'), + o('bgGreenBright', [102, 49], 'bgBright'), + o('bgYellowBright', [103, 49], 'bgBright'), + o('bgBlueBright', [104, 49], 'bgBright'), + o('bgMagentaBright', [105, 49], 'bgBright'), + o('bgCyanBright', [106, 49], 'bgBright'), + o('bgWhiteBright', [107, 49], 'bgBright'), + (e.ansiRegex = A), + (e.hasColor = e.hasAnsi = (t) => ( + (e.ansiRegex.lastIndex = 0), + 'string' == typeof t && '' !== t && e.ansiRegex.test(t) + )), + (e.alias = (t, r) => { + let A = 'string' == typeof r ? e[r] : r; + if ('function' != typeof A) + throw new TypeError( + 'Expected alias to be the name of an existing color (string) or a function' + ); + A.stack || + (Reflect.defineProperty(A, 'name', { value: t }), + (e.styles[t] = A), + (A.stack = [t])), + Reflect.defineProperty(e, t, { + configurable: !0, + enumerable: !0, + set(r) { + e.alias(t, r); + }, + get() { + let t = (e) => n(e, t.stack); + return ( + Reflect.setPrototypeOf(t, e), + (t.stack = this.stack + ? this.stack.concat(A.stack) + : A.stack), + t + ); + }, + }); + }), + (e.theme = (t) => { + if ( + null === (r = t) || + 'object' != typeof r || + Array.isArray(r) + ) + throw new TypeError('Expected theme to be an object'); + var r; + for (let r of Object.keys(t)) e.alias(r, t[r]); + return e; + }), + e.alias('unstyle', (t) => + 'string' == typeof t && '' !== t + ? ((e.ansiRegex.lastIndex = 0), t.replace(e.ansiRegex, '')) + : '' + ), + e.alias('noop', (e) => e), + (e.none = e.clear = e.noop), + (e.stripColor = e.unstyle), + (e.symbols = r(31283)), + (e.define = o), + e + ); + }; + (e.exports = n()), (e.exports.create = n); + }, + 31283: (e) => { + 'use strict'; + const t = 'Hyper' === process.env.TERM_PROGRAM, + r = 'win32' === process.platform, + A = 'linux' === process.platform, + n = { + ballotDisabled: '☒', + ballotOff: '☐', + ballotOn: '☑', + bullet: '•', + bulletWhite: '◦', + fullBlock: '█', + heart: '❤', + identicalTo: '≡', + line: '─', + mark: '※', + middot: '·', + minus: '－', + multiplication: '×', + obelus: '÷', + pencilDownRight: '✎', + pencilRight: '✏', + pencilUpRight: '✐', + percent: '%', + pilcrow2: '❡', + pilcrow: '¶', + plusMinus: '±', + section: '§', + starsOff: '☆', + starsOn: '★', + upDownArrow: '↕', + }, + o = Object.assign({}, n, { + check: '√', + cross: '×', + ellipsisLarge: '...', + ellipsis: '...', + info: 'i', + question: '?', + questionSmall: '?', + pointer: '>', + pointerSmall: '»', + radioOff: '( )', + radioOn: '(*)', + warning: '‼', + }), + i = Object.assign({}, n, { + ballotCross: '✘', + check: '✔', + cross: '✖', + ellipsisLarge: '⋯', + ellipsis: '…', + info: 'ℹ', + question: '?', + questionFull: '？', + questionSmall: '﹖', + pointer: A ? '▸' : '❯', + pointerSmall: A ? '‣' : '›', + radioOff: '◯', + radioOn: '◉', + warning: '⚠', + }); + (e.exports = r && !t ? o : i), + Reflect.defineProperty(e.exports, 'common', { + enumerable: !1, + value: n, + }), + Reflect.defineProperty(e.exports, 'windows', { + enumerable: !1, + value: o, + }), + Reflect.defineProperty(e.exports, 'other', { + enumerable: !1, + value: i, + }); + }, + 18483: (e, t, r) => { + 'use strict'; + e = r.nmd(e); + const A = (e, t) => (...r) => `[${e(...r) + t}m`, + n = (e, t) => (...r) => { + const A = e(...r); + return `[${38 + t};5;${A}m`; + }, + o = (e, t) => (...r) => { + const A = e(...r); + return `[${38 + t};2;${A[0]};${A[1]};${A[2]}m`; + }, + i = (e) => e, + s = (e, t, r) => [e, t, r], + a = (e, t, r) => { + Object.defineProperty(e, t, { + get: () => { + const A = r(); + return ( + Object.defineProperty(e, t, { + value: A, + enumerable: !0, + configurable: !0, + }), + A + ); + }, + enumerable: !0, + configurable: !0, + }); + }; + let c; + const g = (e, t, A, n) => { + void 0 === c && (c = r(2744)); + const o = n ? 10 : 0, + i = {}; + for (const [r, n] of Object.entries(c)) { + const s = 'ansi16' === r ? 'ansi' : r; + r === t + ? (i[s] = e(A, o)) + : 'object' == typeof n && (i[s] = e(n[t], o)); + } + return i; + }; + Object.defineProperty(e, 'exports', { + enumerable: !0, + get: function () { + const e = new Map(), + t = { + modifier: { + reset: [0, 0], + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29], + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + blackBright: [90, 39], + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39], + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + bgBlackBright: [100, 49], + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49], + }, + }; + (t.color.gray = t.color.blackBright), + (t.bgColor.bgGray = t.bgColor.bgBlackBright), + (t.color.grey = t.color.blackBright), + (t.bgColor.bgGrey = t.bgColor.bgBlackBright); + for (const [r, A] of Object.entries(t)) { + for (const [r, n] of Object.entries(A)) + (t[r] = { open: `[${n[0]}m`, close: `[${n[1]}m` }), + (A[r] = t[r]), + e.set(n[0], n[1]); + Object.defineProperty(t, r, { value: A, enumerable: !1 }); + } + return ( + Object.defineProperty(t, 'codes', { value: e, enumerable: !1 }), + (t.color.close = ''), + (t.bgColor.close = ''), + a(t.color, 'ansi', () => g(A, 'ansi16', i, !1)), + a(t.color, 'ansi256', () => g(n, 'ansi256', i, !1)), + a(t.color, 'ansi16m', () => g(o, 'rgb', s, !1)), + a(t.bgColor, 'ansi', () => g(A, 'ansi16', i, !0)), + a(t.bgColor, 'ansi256', () => g(n, 'ansi256', i, !0)), + a(t.bgColor, 'ansi16m', () => g(o, 'rgb', s, !0)), + t + ); + }, + }); + }, + 39920: (e) => { + 'use strict'; + e.exports = (...e) => [...new Set([].concat(...e))]; + }, + 67648: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.getBinjumper = void 0); + const A = r(78761); + let n = null; + t.getBinjumper = function () { + return ( + n || + (n = A.gunzipSync( + Buffer.from( + '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', + 'base64' + ) + )), + n + ); + }; + }, + 50730: (e, t, r) => { + 'use strict'; + t.O9 = void 0; + const A = r(85622), + n = r(35747), + o = r(31669), + i = r(67648); + Object.defineProperty(t, 'O9', { + enumerable: !0, + get: function () { + return i.getBinjumper; + }, + }); + }, + 73975: (e, t, r) => { + 'use strict'; + var A = r(86897).Duplex; + function n(e) { + if (!(this instanceof n)) return new n(e); + if (((this._bufs = []), (this.length = 0), 'function' == typeof e)) { + this._callback = e; + var t = function (e) { + this._callback && (this._callback(e), (this._callback = null)); + }.bind(this); + this.on('pipe', function (e) { + e.on('error', t); + }), + this.on('unpipe', function (e) { + e.removeListener('error', t); + }); + } else this.append(e); + A.call(this); + } + r(31669).inherits(n, A), + (n.prototype._offset = function (e) { + var t, + r = 0, + A = 0; + if (0 === e) return [0, 0]; + for (; A < this._bufs.length; A++) { + if ( + e < (t = r + this._bufs[A].length) || + A == this._bufs.length - 1 + ) + return [A, e - r]; + r = t; + } + }), + (n.prototype._reverseOffset = function (e) { + for (var t = e[0], r = e[1], A = 0; A < t; A++) + r += this._bufs[A].length; + return r; + }), + (n.prototype.append = function (e) { + var t = 0; + if (Buffer.isBuffer(e)) this._appendBuffer(e); + else if (Array.isArray(e)) + for (; t < e.length; t++) this.append(e[t]); + else if (e instanceof n) + for (; t < e._bufs.length; t++) this.append(e._bufs[t]); + else + null != e && + ('number' == typeof e && (e = e.toString()), + this._appendBuffer(Buffer.from(e))); + return this; + }), + (n.prototype._appendBuffer = function (e) { + this._bufs.push(e), (this.length += e.length); + }), + (n.prototype._write = function (e, t, r) { + this._appendBuffer(e), 'function' == typeof r && r(); + }), + (n.prototype._read = function (e) { + if (!this.length) return this.push(null); + (e = Math.min(e, this.length)), + this.push(this.slice(0, e)), + this.consume(e); + }), + (n.prototype.end = function (e) { + A.prototype.end.call(this, e), + this._callback && + (this._callback(null, this.slice()), (this._callback = null)); + }), + (n.prototype.get = function (e) { + if (!(e > this.length || e < 0)) { + var t = this._offset(e); + return this._bufs[t[0]][t[1]]; + } + }), + (n.prototype.slice = function (e, t) { + return ( + 'number' == typeof e && e < 0 && (e += this.length), + 'number' == typeof t && t < 0 && (t += this.length), + this.copy(null, 0, e, t) + ); + }), + (n.prototype.copy = function (e, t, r, A) { + if ( + (('number' != typeof r || r < 0) && (r = 0), + ('number' != typeof A || A > this.length) && (A = this.length), + r >= this.length) + ) + return e || Buffer.alloc(0); + if (A <= 0) return e || Buffer.alloc(0); + var n, + o, + i = !!e, + s = this._offset(r), + a = A - r, + c = a, + g = (i && t) || 0, + l = s[1]; + if (0 === r && A == this.length) { + if (!i) + return 1 === this._bufs.length + ? this._bufs[0] + : Buffer.concat(this._bufs, this.length); + for (o = 0; o < this._bufs.length; o++) + this._bufs[o].copy(e, g), (g += this._bufs[o].length); + return e; + } + if (c <= this._bufs[s[0]].length - l) + return i + ? this._bufs[s[0]].copy(e, t, l, l + c) + : this._bufs[s[0]].slice(l, l + c); + for ( + i || (e = Buffer.allocUnsafe(a)), o = s[0]; + o < this._bufs.length; + o++ + ) { + if (!(c > (n = this._bufs[o].length - l))) { + this._bufs[o].copy(e, g, l, l + c); + break; + } + this._bufs[o].copy(e, g, l), (g += n), (c -= n), l && (l = 0); + } + return e; + }), + (n.prototype.shallowSlice = function (e, t) { + if ( + ((e = e || 0), + (t = 'number' != typeof t ? this.length : t), + e < 0 && (e += this.length), + t < 0 && (t += this.length), + e === t) + ) + return new n(); + var r = this._offset(e), + A = this._offset(t), + o = this._bufs.slice(r[0], A[0] + 1); + return ( + 0 == A[1] + ? o.pop() + : (o[o.length - 1] = o[o.length - 1].slice(0, A[1])), + 0 != r[1] && (o[0] = o[0].slice(r[1])), + new n(o) + ); + }), + (n.prototype.toString = function (e, t, r) { + return this.slice(t, r).toString(e); + }), + (n.prototype.consume = function (e) { + for (; this._bufs.length; ) { + if (!(e >= this._bufs[0].length)) { + (this._bufs[0] = this._bufs[0].slice(e)), (this.length -= e); + break; + } + (e -= this._bufs[0].length), + (this.length -= this._bufs[0].length), + this._bufs.shift(); + } + return this; + }), + (n.prototype.duplicate = function () { + for (var e = 0, t = new n(); e < this._bufs.length; e++) + t.append(this._bufs[e]); + return t; + }), + (n.prototype._destroy = function (e, t) { + (this._bufs.length = 0), (this.length = 0), t(e); + }), + (n.prototype.indexOf = function (e, t, r) { + if ( + (void 0 === r && 'string' == typeof t && ((r = t), (t = void 0)), + 'function' == typeof e || Array.isArray(e)) + ) + throw new TypeError( + 'The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.' + ); + if ( + ('number' == typeof e + ? (e = Buffer.from([e])) + : 'string' == typeof e + ? (e = Buffer.from(e, r)) + : e instanceof n + ? (e = e.slice()) + : Buffer.isBuffer(e) || (e = Buffer.from(e)), + (t = Number(t || 0)), + isNaN(t) && (t = 0), + t < 0 && (t = this.length + t), + t < 0 && (t = 0), + 0 === e.length) + ) + return t > this.length ? this.length : t; + for ( + var A = this._offset(t), o = A[0], i = A[1]; + o < this._bufs.length; + o++ + ) { + for (var s = this._bufs[o]; i < s.length; ) { + if (s.length - i >= e.length) { + var a = s.indexOf(e, i); + if (-1 !== a) return this._reverseOffset([o, a]); + i = s.length - e.length + 1; + } else { + var c = this._reverseOffset([o, i]); + if (this._match(c, e)) return c; + i++; + } + } + i = 0; + } + return -1; + }), + (n.prototype._match = function (e, t) { + if (this.length - e < t.length) return !1; + for (var r = 0; r < t.length; r++) + if (this.get(e + r) !== t[r]) return !1; + return !0; + }), + (function () { + var e = { + readDoubleBE: 8, + readDoubleLE: 8, + readFloatBE: 4, + readFloatLE: 4, + readInt32BE: 4, + readInt32LE: 4, + readUInt32BE: 4, + readUInt32LE: 4, + readInt16BE: 2, + readInt16LE: 2, + readUInt16BE: 2, + readUInt16LE: 2, + readInt8: 1, + readUInt8: 1, + readIntBE: null, + readIntLE: null, + readUIntBE: null, + readUIntLE: null, + }; + for (var t in e) + !(function (t) { + n.prototype[t] = + null === e[t] + ? function (e, r) { + return this.slice(e, e + r)[t](0, r); + } + : function (r) { + return this.slice(r, r + e[t])[t](0); + }; + })(t); + })(), + (e.exports = n); + }, + 12235: (e, t, r) => { + 'use strict'; + const A = r(54900), + n = r(44617), + o = r(1495), + i = r(425), + s = (e, t = {}) => { + let r = []; + if (Array.isArray(e)) + for (let A of e) { + let e = s.create(A, t); + Array.isArray(e) ? r.push(...e) : r.push(e); + } + else r = [].concat(s.create(e, t)); + return ( + t && !0 === t.expand && !0 === t.nodupes && (r = [...new Set(r)]), + r + ); + }; + (s.parse = (e, t = {}) => i(e, t)), + (s.stringify = (e, t = {}) => + A('string' == typeof e ? s.parse(e, t) : e, t)), + (s.compile = (e, t = {}) => ( + 'string' == typeof e && (e = s.parse(e, t)), n(e, t) + )), + (s.expand = (e, t = {}) => { + 'string' == typeof e && (e = s.parse(e, t)); + let r = o(e, t); + return ( + !0 === t.noempty && (r = r.filter(Boolean)), + !0 === t.nodupes && (r = [...new Set(r)]), + r + ); + }), + (s.create = (e, t = {}) => + '' === e || e.length < 3 + ? [e] + : !0 !== t.expand + ? s.compile(e, t) + : s.expand(e, t)), + (e.exports = s); + }, + 44617: (e, t, r) => { + 'use strict'; + const A = r(52169), + n = r(4542); + e.exports = (e, t = {}) => { + let r = (e, o = {}) => { + let i = n.isInvalidBrace(o), + s = !0 === e.invalid && !0 === t.escapeInvalid, + a = !0 === i || !0 === s, + c = !0 === t.escapeInvalid ? '\\' : '', + g = ''; + if (!0 === e.isOpen) return c + e.value; + if (!0 === e.isClose) return c + e.value; + if ('open' === e.type) return a ? c + e.value : '('; + if ('close' === e.type) return a ? c + e.value : ')'; + if ('comma' === e.type) + return 'comma' === e.prev.type ? '' : a ? e.value : '|'; + if (e.value) return e.value; + if (e.nodes && e.ranges > 0) { + let r = n.reduce(e.nodes), + o = A(...r, { ...t, wrap: !1, toRegex: !0 }); + if (0 !== o.length) + return r.length > 1 && o.length > 1 ? `(${o})` : o; + } + if (e.nodes) for (let t of e.nodes) g += r(t, e); + return g; + }; + return r(e); + }; + }, + 5384: (e) => { + 'use strict'; + e.exports = { + MAX_LENGTH: 65536, + CHAR_0: '0', + CHAR_9: '9', + CHAR_UPPERCASE_A: 'A', + CHAR_LOWERCASE_A: 'a', + CHAR_UPPERCASE_Z: 'Z', + CHAR_LOWERCASE_Z: 'z', + CHAR_LEFT_PARENTHESES: '(', + CHAR_RIGHT_PARENTHESES: ')', + CHAR_ASTERISK: '*', + CHAR_AMPERSAND: '&', + CHAR_AT: '@', + CHAR_BACKSLASH: '\\', + CHAR_BACKTICK: '`', + CHAR_CARRIAGE_RETURN: '\r', + CHAR_CIRCUMFLEX_ACCENT: '^', + CHAR_COLON: ':', + CHAR_COMMA: ',', + CHAR_DOLLAR: '$', + CHAR_DOT: '.', + CHAR_DOUBLE_QUOTE: '"', + CHAR_EQUAL: '=', + CHAR_EXCLAMATION_MARK: '!', + CHAR_FORM_FEED: '\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', + CHAR_NO_BREAK_SPACE: ' ', + 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', + CHAR_UNDERSCORE: '_', + CHAR_VERTICAL_LINE: '|', + CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\ufeff', + }; + }, + 1495: (e, t, r) => { + 'use strict'; + const A = r(52169), + n = r(54900), + o = r(4542), + i = (e = '', t = '', r = !1) => { + let A = []; + if (((e = [].concat(e)), !(t = [].concat(t)).length)) return e; + if (!e.length) return r ? o.flatten(t).map((e) => `{${e}}`) : t; + for (let n of e) + if (Array.isArray(n)) for (let e of n) A.push(i(e, t, r)); + else + for (let e of t) + !0 === r && 'string' == typeof e && (e = `{${e}}`), + A.push(Array.isArray(e) ? i(n, e, r) : n + e); + return o.flatten(A); + }; + e.exports = (e, t = {}) => { + let r = void 0 === t.rangeLimit ? 1e3 : t.rangeLimit, + s = (e, a = {}) => { + e.queue = []; + let c = a, + g = a.queue; + for (; 'brace' !== c.type && 'root' !== c.type && c.parent; ) + (c = c.parent), (g = c.queue); + if (e.invalid || e.dollar) + return void g.push(i(g.pop(), n(e, t))); + if ( + 'brace' === e.type && + !0 !== e.invalid && + 2 === e.nodes.length + ) + return void g.push(i(g.pop(), ['{}'])); + if (e.nodes && e.ranges > 0) { + let s = o.reduce(e.nodes); + if (o.exceedsLimit(...s, t.step, r)) + throw new RangeError( + 'expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.' + ); + let a = A(...s, t); + return ( + 0 === a.length && (a = n(e, t)), + g.push(i(g.pop(), a)), + void (e.nodes = []) + ); + } + let l = o.encloseBrace(e), + u = e.queue, + h = e; + for (; 'brace' !== h.type && 'root' !== h.type && h.parent; ) + (h = h.parent), (u = h.queue); + for (let t = 0; t < e.nodes.length; t++) { + let r = e.nodes[t]; + 'comma' !== r.type || 'brace' !== e.type + ? 'close' !== r.type + ? r.value && 'open' !== r.type + ? u.push(i(u.pop(), r.value)) + : r.nodes && s(r, e) + : g.push(i(g.pop(), u, l)) + : (1 === t && u.push(''), u.push('')); + } + return u; + }; + return o.flatten(s(e)); + }; + }, + 425: (e, t, r) => { + 'use strict'; + const A = r(54900), + { + MAX_LENGTH: n, + CHAR_BACKSLASH: o, + CHAR_BACKTICK: i, + CHAR_COMMA: s, + CHAR_DOT: a, + CHAR_LEFT_PARENTHESES: c, + CHAR_RIGHT_PARENTHESES: g, + CHAR_LEFT_CURLY_BRACE: l, + CHAR_RIGHT_CURLY_BRACE: u, + CHAR_LEFT_SQUARE_BRACKET: h, + CHAR_RIGHT_SQUARE_BRACKET: p, + CHAR_DOUBLE_QUOTE: d, + CHAR_SINGLE_QUOTE: C, + CHAR_NO_BREAK_SPACE: f, + CHAR_ZERO_WIDTH_NOBREAK_SPACE: I, + } = r(5384); + e.exports = (e, t = {}) => { + if ('string' != typeof e) throw new TypeError('Expected a string'); + let r = t || {}, + E = 'number' == typeof r.maxLength ? Math.min(n, r.maxLength) : n; + if (e.length > E) + throw new SyntaxError( + `Input length (${e.length}), exceeds max characters (${E})` + ); + let B, + y = { type: 'root', input: e, nodes: [] }, + m = [y], + w = y, + Q = y, + D = 0, + b = e.length, + v = 0, + S = 0; + const k = () => e[v++], + N = (e) => { + if ( + ('text' === e.type && 'dot' === Q.type && (Q.type = 'text'), + !Q || 'text' !== Q.type || 'text' !== e.type) + ) + return ( + w.nodes.push(e), (e.parent = w), (e.prev = Q), (Q = e), e + ); + Q.value += e.value; + }; + for (N({ type: 'bos' }); v < b; ) + if (((w = m[m.length - 1]), (B = k()), B !== I && B !== f)) + if (B !== o) + if (B !== p) + if (B !== h) + if (B !== c) + if (B !== g) + if (B !== d && B !== C && B !== i) + if (B !== l) + if (B !== u) + if (B === s && S > 0) { + if (w.ranges > 0) { + w.ranges = 0; + let e = w.nodes.shift(); + w.nodes = [e, { type: 'text', value: A(w) }]; + } + N({ type: 'comma', value: B }), w.commas++; + } else if (B === a && S > 0 && 0 === w.commas) { + let e = w.nodes; + if (0 === S || 0 === e.length) { + N({ type: 'text', value: B }); + continue; + } + if ('dot' === Q.type) { + if ( + ((w.range = []), + (Q.value += B), + (Q.type = 'range'), + 3 !== w.nodes.length && + 5 !== w.nodes.length) + ) { + (w.invalid = !0), + (w.ranges = 0), + (Q.type = 'text'); + continue; + } + w.ranges++, (w.args = []); + continue; + } + if ('range' === Q.type) { + e.pop(); + let t = e[e.length - 1]; + (t.value += Q.value + B), (Q = t), w.ranges--; + continue; + } + N({ type: 'dot', value: B }); + } else N({ type: 'text', value: B }); + else { + if ('brace' !== w.type) { + N({ type: 'text', value: B }); + continue; + } + let e = 'close'; + (w = m.pop()), + (w.close = !0), + N({ type: e, value: B }), + S--, + (w = m[m.length - 1]); + } + else { + S++; + let e = + (Q.value && '$' === Q.value.slice(-1)) || + !0 === w.dollar; + (w = N({ + type: 'brace', + open: !0, + close: !1, + dollar: e, + depth: S, + commas: 0, + ranges: 0, + nodes: [], + })), + m.push(w), + N({ type: 'open', value: B }); + } + else { + let e, + r = B; + for ( + !0 !== t.keepQuotes && (B = ''); + v < b && (e = k()); + + ) + if (e !== o) { + if (e === r) { + !0 === t.keepQuotes && (B += e); + break; + } + B += e; + } else B += e + k(); + N({ type: 'text', value: B }); + } + else { + if ('paren' !== w.type) { + N({ type: 'text', value: B }); + continue; + } + (w = m.pop()), + N({ type: 'text', value: B }), + (w = m[m.length - 1]); + } + else + (w = N({ type: 'paren', nodes: [] })), + m.push(w), + N({ type: 'text', value: B }); + else { + D++; + let e; + for (; v < b && (e = k()); ) + if (((B += e), e !== h)) + if (e !== o) { + if (e === p && (D--, 0 === D)) break; + } else B += k(); + else D++; + N({ type: 'text', value: B }); + } + else N({ type: 'text', value: '\\' + B }); + else N({ type: 'text', value: (t.keepEscaping ? B : '') + k() }); + do { + if (((w = m.pop()), 'root' !== w.type)) { + w.nodes.forEach((e) => { + e.nodes || + ('open' === e.type && (e.isOpen = !0), + 'close' === e.type && (e.isClose = !0), + e.nodes || (e.type = 'text'), + (e.invalid = !0)); + }); + let e = m[m.length - 1], + t = e.nodes.indexOf(w); + e.nodes.splice(t, 1, ...w.nodes); + } + } while (m.length > 0); + return N({ type: 'eos' }), y; + }; + }, + 54900: (e, t, r) => { + 'use strict'; + const A = r(4542); + e.exports = (e, t = {}) => { + let r = (e, n = {}) => { + let o = t.escapeInvalid && A.isInvalidBrace(n), + i = !0 === e.invalid && !0 === t.escapeInvalid, + s = ''; + if (e.value) + return (o || i) && A.isOpenOrClose(e) ? '\\' + e.value : e.value; + if (e.value) return e.value; + if (e.nodes) for (let t of e.nodes) s += r(t); + return s; + }; + return r(e); + }; + }, + 4542: (e, t) => { + 'use strict'; + (t.isInteger = (e) => + 'number' == typeof e + ? Number.isInteger(e) + : 'string' == typeof e && + '' !== e.trim() && + Number.isInteger(Number(e))), + (t.find = (e, t) => e.nodes.find((e) => e.type === t)), + (t.exceedsLimit = (e, r, A = 1, n) => + !1 !== n && + !(!t.isInteger(e) || !t.isInteger(r)) && + (Number(r) - Number(e)) / Number(A) >= n), + (t.escapeNode = (e, t = 0, r) => { + let A = e.nodes[t]; + A && + ((r && A.type === r) || + 'open' === A.type || + 'close' === A.type) && + !0 !== A.escaped && + ((A.value = '\\' + A.value), (A.escaped = !0)); + }), + (t.encloseBrace = (e) => + 'brace' === e.type && + (e.commas >> (0 + e.ranges)) >> 0 == 0 && + ((e.invalid = !0), !0)), + (t.isInvalidBrace = (e) => + 'brace' === e.type && + (!(!0 !== e.invalid && !e.dollar) || + (((e.commas >> (0 + e.ranges)) >> 0 == 0 || + !0 !== e.open || + !0 !== e.close) && + ((e.invalid = !0), !0)))), + (t.isOpenOrClose = (e) => + 'open' === e.type || + 'close' === e.type || + !0 === e.open || + !0 === e.close), + (t.reduce = (e) => + e.reduce( + (e, t) => ( + 'text' === t.type && e.push(t.value), + 'range' === t.type && (t.type = 'text'), + e + ), + [] + )), + (t.flatten = (...e) => { + const t = [], + r = (e) => { + for (let A = 0; A < e.length; A++) { + let n = e[A]; + Array.isArray(n) ? r(n, t) : void 0 !== n && t.push(n); + } + return t; + }; + return r(e), t; + }); + }, + 30093: (e, t, r) => { + 'use strict'; + const { + V4MAPPED: A, + ADDRCONFIG: n, + ALL: o, + promises: { Resolver: i }, + lookup: s, + } = r(40881), + { promisify: a } = r(31669), + c = r(12087), + g = Symbol('cacheableLookupCreateConnection'), + l = Symbol('cacheableLookupInstance'), + u = Symbol('expires'), + h = 'number' == typeof o, + p = (e) => { + if (!e || 'function' != typeof e.createConnection) + throw new Error( + 'Expected an Agent instance as the first argument' + ); + }, + d = () => { + let e = !1, + t = !1; + for (const r of Object.values(c.networkInterfaces())) + for (const A of r) + if ( + !A.internal && + ('IPv6' === A.family ? (t = !0) : (e = !0), e && t) + ) + return { has4: e, has6: t }; + return { has4: e, has6: t }; + }, + C = { ttl: !0 }, + f = { all: !0 }; + class I { + constructor({ + cache: e = new Map(), + maxTtl: t = 1 / 0, + fallbackDuration: r = 3600, + errorTtl: A = 0.15, + resolver: n = new i(), + lookup: o = s, + } = {}) { + if ( + ((this.maxTtl = t), + (this.errorTtl = A), + (this._cache = e), + (this._resolver = n), + (this._dnsLookup = a(o)), + this._resolver instanceof i + ? ((this._resolve4 = this._resolver.resolve4.bind( + this._resolver + )), + (this._resolve6 = this._resolver.resolve6.bind( + this._resolver + ))) + : ((this._resolve4 = a( + this._resolver.resolve4.bind(this._resolver) + )), + (this._resolve6 = a( + this._resolver.resolve6.bind(this._resolver) + ))), + (this._iface = d()), + (this._pending = {}), + (this._nextRemovalTime = !1), + (this._hostnamesToFallback = new Set()), + r < 1) + ) + this._fallback = !1; + else { + this._fallback = !0; + const e = setInterval(() => { + this._hostnamesToFallback.clear(); + }, 1e3 * r); + e.unref && e.unref(); + } + (this.lookup = this.lookup.bind(this)), + (this.lookupAsync = this.lookupAsync.bind(this)); + } + set servers(e) { + this.clear(), this._resolver.setServers(e); + } + get servers() { + return this._resolver.getServers(); + } + lookup(e, t, r) { + if ( + ('function' == typeof t + ? ((r = t), (t = {})) + : 'number' == typeof t && (t = { family: t }), + !r) + ) + throw new Error('Callback must be a function.'); + this.lookupAsync(e, t).then((e) => { + t.all + ? r(null, e) + : r(null, e.address, e.family, e.expires, e.ttl); + }, r); + } + async lookupAsync(e, t = {}) { + 'number' == typeof t && (t = { family: t }); + let r = await this.query(e); + if (6 === t.family) { + const e = r.filter((e) => 6 === e.family); + t.hints & A && ((h && t.hints & o) || 0 === e.length) + ? ((e) => { + for (const t of e) + 6 !== t.family && + ((t.address = '::ffff:' + t.address), (t.family = 6)); + })(r) + : (r = e); + } else 4 === t.family && (r = r.filter((e) => 4 === e.family)); + if (t.hints & n) { + const { _iface: e } = this; + r = r.filter((t) => (6 === t.family ? e.has6 : e.has4)); + } + if (0 === r.length) { + const t = new Error('cacheableLookup ENOTFOUND ' + e); + throw ((t.code = 'ENOTFOUND'), (t.hostname = e), t); + } + return t.all ? r : r[0]; + } + async query(e) { + let t = await this._cache.get(e); + if (!t) { + const r = this._pending[e]; + if (r) t = await r; + else { + const r = this.queryAndCache(e); + (this._pending[e] = r), (t = await r); + } + } + return (t = t.map((e) => ({ ...e }))), t; + } + async _resolve(e) { + const [t, r] = await Promise.all( + [this._resolve4(e, C), this._resolve6(e, C)].map((e) => + (async (e) => { + try { + return await e; + } catch (e) { + if ('ENODATA' === e.code || 'ENOTFOUND' === e.code) + return []; + throw e; + } + })(e) + ) + ); + let A = 0, + n = 0, + o = 0; + const i = Date.now(); + for (const e of t) + (e.family = 4), + (e.expires = i + 1e3 * e.ttl), + (A = Math.max(A, e.ttl)); + for (const e of r) + (e.family = 6), + (e.expires = i + 1e3 * e.ttl), + (n = Math.max(n, e.ttl)); + return ( + (o = t.length > 0 ? (r.length > 0 ? Math.min(A, n) : A) : n), + { entries: [...t, ...r], cacheTtl: o } + ); + } + async _lookup(e) { + try { + return { + entries: await this._dnsLookup(e, { all: !0 }), + cacheTtl: 0, + }; + } catch (e) { + return { entries: [], cacheTtl: 0 }; + } + } + async _set(e, t, r) { + if (this.maxTtl > 0 && r > 0) { + (r = 1e3 * Math.min(r, this.maxTtl)), (t[u] = Date.now() + r); + try { + await this._cache.set(e, t, r); + } catch (e) { + this.lookupAsync = async () => { + const t = new Error( + 'Cache Error. Please recreate the CacheableLookup instance.' + ); + throw ((t.cause = e), t); + }; + } + (A = this._cache), Symbol.iterator in A && this._tick(r); + } + var A; + } + async queryAndCache(e) { + if (this._hostnamesToFallback.has(e)) return this._dnsLookup(e, f); + try { + let t = await this._resolve(e); + 0 === t.entries.length && + this._fallback && + ((t = await this._lookup(e)), + 0 !== t.entries.length && this._hostnamesToFallback.add(e)); + const r = 0 === t.entries.length ? this.errorTtl : t.cacheTtl; + return ( + await this._set(e, t.entries, r), + delete this._pending[e], + t.entries + ); + } catch (t) { + throw (delete this._pending[e], t); + } + } + _tick(e) { + const t = this._nextRemovalTime; + (!t || e < t) && + (clearTimeout(this._removalTimeout), + (this._nextRemovalTime = e), + (this._removalTimeout = setTimeout(() => { + this._nextRemovalTime = !1; + let e = 1 / 0; + const t = Date.now(); + for (const [r, A] of this._cache) { + const n = A[u]; + t >= n ? this._cache.delete(r) : n < e && (e = n); + } + e !== 1 / 0 && this._tick(e - t); + }, e)), + this._removalTimeout.unref && this._removalTimeout.unref()); + } + install(e) { + if ((p(e), g in e)) + throw new Error('CacheableLookup has been already installed'); + (e[g] = e.createConnection), + (e[l] = this), + (e.createConnection = (t, r) => ( + 'lookup' in t || (t.lookup = this.lookup), e[g](t, r) + )); + } + uninstall(e) { + if ((p(e), e[g])) { + if (e[l] !== this) + throw new Error( + 'The agent is not owned by this CacheableLookup instance' + ); + (e.createConnection = e[g]), delete e[g], delete e[l]; + } + } + updateInterfaceInfo() { + const { _iface: e } = this; + (this._iface = d()), + ((e.has4 && !this._iface.has4) || + (e.has6 && !this._iface.has6)) && + this._cache.clear(); + } + clear(e) { + e ? this._cache.delete(e) : this._cache.clear(); + } + } + (e.exports = I), (e.exports.default = I); + }, + 11200: (e, t, r) => { + 'use strict'; + const A = r(28614), + n = r(78835), + o = r(19793), + i = r(58764), + s = r(86834), + a = r(48491), + c = r(55737), + g = r(15751), + l = r(72515); + class u { + constructor(e, t) { + if ('function' != typeof e) + throw new TypeError('Parameter `request` must be a function'); + return ( + (this.cache = new l({ + uri: 'string' == typeof t && t, + store: 'string' != typeof t && t, + namespace: 'cacheable-request', + })), + this.createCacheableRequest(e) + ); + } + createCacheableRequest(e) { + return (t, r) => { + let l; + if ('string' == typeof t) (l = p(n.parse(t))), (t = {}); + else if (t instanceof n.URL) + (l = p(n.parse(t.toString()))), (t = {}); + else { + const [e, ...r] = (t.path || '').split('?'), + A = r.length > 0 ? '?' + r.join('?') : ''; + l = p({ ...t, pathname: e, search: A }); + } + (t = { + headers: {}, + method: 'GET', + cache: !0, + strictTtl: !1, + automaticFailover: !1, + ...t, + ...h(l), + }).headers = c(t.headers); + const d = new A(), + C = o(n.format(l), { + stripWWW: !1, + removeTrailingSlash: !1, + stripAuthentication: !1, + }), + f = `${t.method}:${C}`; + let I = !1, + E = !1; + const B = (t) => { + E = !0; + let A, + n = !1; + const o = new Promise((e) => { + A = () => { + n || ((n = !0), e()); + }; + }), + c = (e) => { + if (I && !t.forceRefresh) { + e.status = e.statusCode; + const r = s + .fromObject(I.cachePolicy) + .revalidatedPolicy(t, e); + if (!r.modified) { + const t = r.policy.responseHeaders(); + ((e = new a( + I.statusCode, + t, + I.body, + I.url + )).cachePolicy = r.policy), + (e.fromCache = !0); + } + } + let A; + e.fromCache || + ((e.cachePolicy = new s(t, e, t)), (e.fromCache = !1)), + t.cache && e.cachePolicy.storable() + ? ((A = g(e)), + (async () => { + try { + const r = i.buffer(e); + if ( + (await Promise.race([ + o, + new Promise((t) => e.once('end', t)), + ]), + n) + ) + return; + const A = await r, + s = { + cachePolicy: e.cachePolicy.toObject(), + url: e.url, + statusCode: e.fromCache + ? I.statusCode + : e.statusCode, + body: A, + }; + let a = t.strictTtl + ? e.cachePolicy.timeToLive() + : void 0; + t.maxTtl && + (a = a ? Math.min(a, t.maxTtl) : t.maxTtl), + await this.cache.set(f, s, a); + } catch (e) { + d.emit('error', new u.CacheError(e)); + } + })()) + : t.cache && + I && + (async () => { + try { + await this.cache.delete(f); + } catch (e) { + d.emit('error', new u.CacheError(e)); + } + })(), + d.emit('response', A || e), + 'function' == typeof r && r(A || e); + }; + try { + const r = e(t, c); + r.once('error', A), r.once('abort', A), d.emit('request', r); + } catch (e) { + d.emit('error', new u.RequestError(e)); + } + }; + return ( + (async () => { + const e = async (e) => { + await Promise.resolve(); + const t = e.cache ? await this.cache.get(f) : void 0; + if (void 0 === t) return B(e); + const A = s.fromObject(t.cachePolicy); + if ( + A.satisfiesWithoutRevalidation(e) && + !e.forceRefresh + ) { + const e = A.responseHeaders(), + n = new a(t.statusCode, e, t.body, t.url); + (n.cachePolicy = A), + (n.fromCache = !0), + d.emit('response', n), + 'function' == typeof r && r(n); + } else + (I = t), (e.headers = A.revalidationHeaders(e)), B(e); + }, + A = (e) => d.emit('error', new u.CacheError(e)); + this.cache.once('error', A), + d.on('response', () => + this.cache.removeListener('error', A) + ); + try { + await e(t); + } catch (e) { + t.automaticFailover && !E && B(t), + d.emit('error', new u.CacheError(e)); + } + })(), + d + ); + }; + } + } + function h(e) { + const t = { ...e }; + return ( + (t.path = `${e.pathname || '/'}${e.search || ''}`), + delete t.pathname, + delete t.search, + t + ); + } + function p(e) { + return { + protocol: e.protocol, + auth: e.auth, + hostname: e.hostname || e.host || 'localhost', + port: e.port, + pathname: e.pathname, + search: e.search, + }; + } + (u.RequestError = class extends Error { + constructor(e) { + super(e.message), + (this.name = 'RequestError'), + Object.assign(this, e); + } + }), + (u.CacheError = class extends Error { + constructor(e) { + super(e.message), + (this.name = 'CacheError'), + Object.assign(this, e); + } + }), + (e.exports = u); + }, + 54738: (e) => { + 'use strict'; + const t = (e, t) => { + if ('string' != typeof e && !Array.isArray(e)) + throw new TypeError('Expected the input to be `string | string[]`'); + t = Object.assign({ pascalCase: !1 }, t); + if ( + 0 === + (e = Array.isArray(e) + ? e + .map((e) => e.trim()) + .filter((e) => e.length) + .join('-') + : e.trim()).length + ) + return ''; + if (1 === e.length) + return t.pascalCase ? e.toUpperCase() : e.toLowerCase(); + return ( + e !== e.toLowerCase() && + (e = ((e) => { + let t = !1, + r = !1, + A = !1; + for (let n = 0; n < e.length; n++) { + const o = e[n]; + t && /[a-zA-Z]/.test(o) && o.toUpperCase() === o + ? ((e = e.slice(0, n) + '-' + e.slice(n)), + (t = !1), + (A = r), + (r = !0), + n++) + : r && A && /[a-zA-Z]/.test(o) && o.toLowerCase() === o + ? ((e = e.slice(0, n - 1) + '-' + e.slice(n - 1)), + (A = r), + (r = !1), + (t = !0)) + : ((t = o.toLowerCase() === o && o.toUpperCase() !== o), + (A = r), + (r = o.toUpperCase() === o && o.toLowerCase() !== o)); + } + return e; + })(e)), + (e = e + .replace(/^[_.\- ]+/, '') + .toLowerCase() + .replace(/[_.\- ]+(\w|$)/g, (e, t) => t.toUpperCase()) + .replace(/\d+(\w|$)/g, (e) => e.toUpperCase())), + (r = e), + t.pascalCase ? r.charAt(0).toUpperCase() + r.slice(1) : r + ); + var r; + }; + (e.exports = t), (e.exports.default = t); + }, + 95882: (e, t, r) => { + 'use strict'; + const A = r(18483), + { stdout: n, stderr: o } = r(59428), + { stringReplaceAll: i, stringEncaseCRLFWithFirstIndex: s } = r(73327), + a = ['ansi', 'ansi', 'ansi256', 'ansi16m'], + c = Object.create(null); + class g { + constructor(e) { + return l(e); + } + } + const l = (e) => { + const t = {}; + return ( + ((e, t = {}) => { + if (t.level > 3 || t.level < 0) + throw new Error( + 'The `level` option should be an integer from 0 to 3' + ); + const r = n ? n.level : 0; + e.level = void 0 === t.level ? r : t.level; + })(t, e), + (t.template = (...e) => E(t.template, ...e)), + Object.setPrototypeOf(t, u.prototype), + Object.setPrototypeOf(t.template, t), + (t.template.constructor = () => { + throw new Error( + '`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.' + ); + }), + (t.template.Instance = g), + t.template + ); + }; + function u(e) { + return l(e); + } + for (const [e, t] of Object.entries(A)) + c[e] = { + get() { + const r = C( + this, + d(t.open, t.close, this._styler), + this._isEmpty + ); + return Object.defineProperty(this, e, { value: r }), r; + }, + }; + c.visible = { + get() { + const e = C(this, this._styler, !0); + return Object.defineProperty(this, 'visible', { value: e }), e; + }, + }; + const h = [ + 'rgb', + 'hex', + 'keyword', + 'hsl', + 'hsv', + 'hwb', + 'ansi', + 'ansi256', + ]; + for (const e of h) + c[e] = { + get() { + const { level: t } = this; + return function (...r) { + const n = d( + A.color[a[t]][e](...r), + A.color.close, + this._styler + ); + return C(this, n, this._isEmpty); + }; + }, + }; + for (const e of h) { + c['bg' + e[0].toUpperCase() + e.slice(1)] = { + get() { + const { level: t } = this; + return function (...r) { + const n = d( + A.bgColor[a[t]][e](...r), + A.bgColor.close, + this._styler + ); + return C(this, n, this._isEmpty); + }; + }, + }; + } + const p = Object.defineProperties(() => {}, { + ...c, + level: { + enumerable: !0, + get() { + return this._generator.level; + }, + set(e) { + this._generator.level = e; + }, + }, + }), + d = (e, t, r) => { + let A, n; + return ( + void 0 === r + ? ((A = e), (n = t)) + : ((A = r.openAll + e), (n = t + r.closeAll)), + { open: e, close: t, openAll: A, closeAll: n, parent: r } + ); + }, + C = (e, t, r) => { + const A = (...e) => f(A, 1 === e.length ? '' + e[0] : e.join(' ')); + return ( + (A.__proto__ = p), + (A._generator = e), + (A._styler = t), + (A._isEmpty = r), + A + ); + }, + f = (e, t) => { + if (e.level <= 0 || !t) return e._isEmpty ? '' : t; + let r = e._styler; + if (void 0 === r) return t; + const { openAll: A, closeAll: n } = r; + if (-1 !== t.indexOf('')) + for (; void 0 !== r; ) + (t = i(t, r.close, r.open)), (r = r.parent); + const o = t.indexOf('\n'); + return -1 !== o && (t = s(t, n, A, o)), A + t + n; + }; + let I; + const E = (e, ...t) => { + const [A] = t; + if (!Array.isArray(A)) return t.join(' '); + const n = t.slice(1), + o = [A.raw[0]]; + for (let e = 1; e < A.length; e++) + o.push( + String(n[e - 1]).replace(/[{}\\]/g, '\\$&'), + String(A.raw[e]) + ); + return void 0 === I && (I = r(80690)), I(e, o.join('')); + }; + Object.defineProperties(u.prototype, c); + const B = u(); + (B.supportsColor = n), + (B.stderr = u({ level: o ? o.level : 0 })), + (B.stderr.supportsColor = o), + (B.Level = { + None: 0, + Basic: 1, + Ansi256: 2, + TrueColor: 3, + 0: 'None', + 1: 'Basic', + 2: 'Ansi256', + 3: 'TrueColor', + }), + (e.exports = B); + }, + 80690: (e) => { + 'use strict'; + const t = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi, + r = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g, + A = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/, + n = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi, + o = new Map([ + ['n', '\n'], + ['r', '\r'], + ['t', '\t'], + ['b', '\b'], + ['f', '\f'], + ['v', '\v'], + ['0', '\0'], + ['\\', '\\'], + ['e', ''], + ['a', ''], + ]); + function i(e) { + const t = 'u' === e[0], + r = '{' === e[1]; + return (t && !r && 5 === e.length) || ('x' === e[0] && 3 === e.length) + ? String.fromCharCode(parseInt(e.slice(1), 16)) + : t && r + ? String.fromCodePoint(parseInt(e.slice(2, -1), 16)) + : o.get(e) || e; + } + function s(e, t) { + const r = [], + o = t.trim().split(/\s*,\s*/g); + let s; + for (const t of o) { + const o = Number(t); + if (Number.isNaN(o)) { + if (!(s = t.match(A))) + throw new Error( + `Invalid Chalk template style argument: ${t} (in style '${e}')` + ); + r.push(s[2].replace(n, (e, t, r) => (t ? i(t) : r))); + } else r.push(o); + } + return r; + } + function a(e) { + r.lastIndex = 0; + const t = []; + let A; + for (; null !== (A = r.exec(e)); ) { + const e = A[1]; + if (A[2]) { + const r = s(e, A[2]); + t.push([e].concat(r)); + } else t.push([e]); + } + return t; + } + function c(e, t) { + const r = {}; + for (const e of t) + for (const t of e.styles) r[t[0]] = e.inverse ? null : t.slice(1); + let A = e; + for (const [e, t] of Object.entries(r)) + if (Array.isArray(t)) { + if (!(e in A)) throw new Error('Unknown Chalk style: ' + e); + A = t.length > 0 ? A[e](...t) : A[e]; + } + return A; + } + e.exports = (e, r) => { + const A = [], + n = []; + let o = []; + if ( + (r.replace(t, (t, r, s, g, l, u) => { + if (r) o.push(i(r)); + else if (g) { + const t = o.join(''); + (o = []), + n.push(0 === A.length ? t : c(e, A)(t)), + A.push({ inverse: s, styles: a(g) }); + } else if (l) { + if (0 === A.length) + throw new Error( + 'Found extraneous } in Chalk template literal' + ); + n.push(c(e, A)(o.join(''))), (o = []), A.pop(); + } else o.push(u); + }), + n.push(o.join('')), + A.length > 0) + ) { + const e = `Chalk template literal is missing ${ + A.length + } closing bracket${1 === A.length ? '' : 's'} (\`}\`)`; + throw new Error(e); + } + return n.join(''); + }; + }, + 73327: (e) => { + 'use strict'; + e.exports = { + stringReplaceAll: (e, t, r) => { + let A = e.indexOf(t); + if (-1 === A) return e; + const n = t.length; + let o = 0, + i = ''; + do { + (i += e.substr(o, A - o) + t + r), + (o = A + n), + (A = e.indexOf(t, o)); + } while (-1 !== A); + return (i += e.substr(o)), i; + }, + stringEncaseCRLFWithFirstIndex: (e, t, r, A) => { + let n = 0, + o = ''; + do { + const i = '\r' === e[A - 1]; + (o += + e.substr(n, (i ? A - 1 : A) - n) + t + (i ? '\r\n' : '\n') + r), + (n = A + 1), + (A = e.indexOf('\n', n)); + } while (-1 !== A); + return (o += e.substr(n)), o; + }, + }; + }, + 5864: (e, t, r) => { + 'use strict'; + var A = r(85832), + n = process.env; + function o(e) { + return 'string' == typeof e + ? !!n[e] + : Object.keys(e).every(function (t) { + return n[t] === e[t]; + }); + } + Object.defineProperty(t, '_vendors', { + value: A.map(function (e) { + return e.constant; + }), + }), + (t.name = null), + (t.isPR = null), + A.forEach(function (e) { + var r = (Array.isArray(e.env) ? e.env : [e.env]).every(function ( + e + ) { + return o(e); + }); + if (((t[e.constant] = r), r)) + switch (((t.name = e.name), typeof e.pr)) { + case 'string': + t.isPR = !!n[e.pr]; + break; + case 'object': + 'env' in e.pr + ? (t.isPR = e.pr.env in n && n[e.pr.env] !== e.pr.ne) + : 'any' in e.pr + ? (t.isPR = e.pr.any.some(function (e) { + return !!n[e]; + })) + : (t.isPR = o(e.pr)); + break; + default: + t.isPR = null; + } + }), + (t.isCI = !!( + n.CI || + n.CONTINUOUS_INTEGRATION || + n.BUILD_NUMBER || + n.RUN_ID || + t.name + )); + }, + 85832: (e) => { + 'use strict'; + e.exports = JSON.parse( + '[{"name":"AppVeyor","constant":"APPVEYOR","env":"APPVEYOR","pr":"APPVEYOR_PULL_REQUEST_NUMBER"},{"name":"Azure Pipelines","constant":"AZURE_PIPELINES","env":"SYSTEM_TEAMFOUNDATIONCOLLECTIONURI","pr":"SYSTEM_PULLREQUEST_PULLREQUESTID"},{"name":"Bamboo","constant":"BAMBOO","env":"bamboo_planKey"},{"name":"Bitbucket Pipelines","constant":"BITBUCKET","env":"BITBUCKET_COMMIT","pr":"BITBUCKET_PR_ID"},{"name":"Bitrise","constant":"BITRISE","env":"BITRISE_IO","pr":"BITRISE_PULL_REQUEST"},{"name":"Buddy","constant":"BUDDY","env":"BUDDY_WORKSPACE_ID","pr":"BUDDY_EXECUTION_PULL_REQUEST_ID"},{"name":"Buildkite","constant":"BUILDKITE","env":"BUILDKITE","pr":{"env":"BUILDKITE_PULL_REQUEST","ne":"false"}},{"name":"CircleCI","constant":"CIRCLE","env":"CIRCLECI","pr":"CIRCLE_PULL_REQUEST"},{"name":"Cirrus CI","constant":"CIRRUS","env":"CIRRUS_CI","pr":"CIRRUS_PR"},{"name":"AWS CodeBuild","constant":"CODEBUILD","env":"CODEBUILD_BUILD_ARN"},{"name":"Codeship","constant":"CODESHIP","env":{"CI_NAME":"codeship"}},{"name":"Drone","constant":"DRONE","env":"DRONE","pr":{"DRONE_BUILD_EVENT":"pull_request"}},{"name":"dsari","constant":"DSARI","env":"DSARI"},{"name":"GitLab CI","constant":"GITLAB","env":"GITLAB_CI"},{"name":"GoCD","constant":"GOCD","env":"GO_PIPELINE_LABEL"},{"name":"Hudson","constant":"HUDSON","env":"HUDSON_URL"},{"name":"Jenkins","constant":"JENKINS","env":["JENKINS_URL","BUILD_ID"],"pr":{"any":["ghprbPullId","CHANGE_ID"]}},{"name":"Magnum CI","constant":"MAGNUM","env":"MAGNUM"},{"name":"Netlify CI","constant":"NETLIFY","env":"NETLIFY_BUILD_BASE","pr":{"env":"PULL_REQUEST","ne":"false"}},{"name":"Sail CI","constant":"SAIL","env":"SAILCI","pr":"SAIL_PULL_REQUEST_NUMBER"},{"name":"Semaphore","constant":"SEMAPHORE","env":"SEMAPHORE","pr":"PULL_REQUEST_NUMBER"},{"name":"Shippable","constant":"SHIPPABLE","env":"SHIPPABLE","pr":{"IS_PULL_REQUEST":"true"}},{"name":"Solano CI","constant":"SOLANO","env":"TDDIUM","pr":"TDDIUM_PR_ID"},{"name":"Strider CD","constant":"STRIDER","env":"STRIDER"},{"name":"TaskCluster","constant":"TASKCLUSTER","env":["TASK_ID","RUN_ID"]},{"name":"TeamCity","constant":"TEAMCITY","env":"TEAMCITY_VERSION"},{"name":"Travis CI","constant":"TRAVIS","env":"TRAVIS","pr":{"env":"TRAVIS_PULL_REQUEST","ne":"false"}}]' + ); + }, + 40822: (e, t, r) => { + 'use strict'; + r.r(t), r.d(t, { Cli: () => Y, Command: () => M, UsageError: () => a }); + const A = /^(-h|--help)(?:=([0-9]+))?$/, + n = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/, + o = /^-[a-zA-Z]{2,}$/, + i = /^([^=]+)=([\s\S]*)$/, + s = '1' === process.env.DEBUG_CLI; + class a extends Error { + constructor(e) { + super(e), + (this.clipanion = { type: 'usage' }), + (this.name = 'UsageError'); + } + } + class c extends Error { + constructor(e, t) { + if ( + (super(), + (this.input = e), + (this.candidates = t), + (this.clipanion = { type: 'none' }), + (this.name = 'UnknownSyntaxError'), + 0 === this.candidates.length) + ) + this.message = + "Command not found, but we're not sure what's the alternative."; + else if ( + 1 === this.candidates.length && + null !== this.candidates[0].reason + ) { + const [{ usage: e, reason: t }] = this.candidates; + this.message = `${t}\n\n$ ${e}`; + } else if (1 === this.candidates.length) { + const [{ usage: t }] = this.candidates; + this.message = `Command not found; did you mean:\n\n$ ${t}\n${l( + e + )}`; + } else + this.message = `Command not found; did you mean one of:\n\n${this.candidates + .map(({ usage: e }, t) => `${(t + '.').padStart(4)} ${e}`) + .join('\n')}\n\n${l(e)}`; + } + } + class g extends Error { + constructor(e, t) { + super(), + (this.input = e), + (this.usages = t), + (this.clipanion = { type: 'none' }), + (this.name = 'AmbiguousSyntaxError'), + (this.message = `Cannot find who to pick amongst the following alternatives:\n\n${this.usages + .map((e, t) => `${(t + '.').padStart(4)} ${e}`) + .join('\n')}\n\n${l(e)}`); + } + } + const l = (e) => + 'While running ' + + e + .filter((e) => '\0' !== e) + .map((e) => { + const t = JSON.stringify(e); + return e.match(/\s/) || 0 === e.length || t !== `"${e}"` ? t : e; + }) + .join(' '); + function u(e) { + s && console.log(e); + } + const h = { + candidateUsage: null, + errorMessage: null, + ignoreOptions: !1, + path: [], + positionals: [], + options: [], + remainder: null, + selectedIndex: -1, + }; + function p(e, t) { + return e.nodes.push(t), e.nodes.length - 1; + } + function d(e, t, r = !1) { + u('Running a vm on ' + JSON.stringify(t)); + let A = [ + { + node: 0, + state: { + candidateUsage: null, + errorMessage: null, + ignoreOptions: !1, + options: [], + path: [], + positionals: [], + remainder: null, + selectedIndex: null, + }, + }, + ]; + !(function (e, { prefix: t = '' } = {}) { + u(t + 'Nodes are:'); + for (let r = 0; r < e.nodes.length; ++r) + u(`${t} ${r}: ${JSON.stringify(e.nodes[r])}`); + })(e, { prefix: ' ' }); + const n = ['', ...t]; + for (let o = 0; o < n.length; ++o) { + const i = n[o]; + u(' Processing ' + JSON.stringify(i)); + const s = []; + for (const { node: t, state: a } of A) { + u(' Current node is ' + t); + const A = e.nodes[t]; + if (2 === t) { + s.push({ node: t, state: a }); + continue; + } + console.assert( + 0 === A.shortcuts.length, + 'Shortcuts should have been eliminated by now' + ); + const c = Object.prototype.hasOwnProperty.call(A.statics, i); + if (!r || o < n.length - 1 || c) + if (c) { + const e = A.statics[i]; + for (const { to: t, reducer: r } of e) + s.push({ + node: t, + state: void 0 !== r ? b(k, r, a, i) : a, + }), + u(` Static transition to ${t} found`); + } else u(' No static transition found'); + else { + let e = !1; + for (const t of Object.keys(A.statics)) + if (t.startsWith(i)) { + if (i === t) + for (const { to: e, reducer: r } of A.statics[t]) + s.push({ + node: e, + state: void 0 !== r ? b(k, r, a, i) : a, + }), + u(` Static transition to ${e} found`); + else + for (const { to: e, reducer: r } of A.statics[t]) + s.push({ + node: e, + state: Object.assign(Object.assign({}, a), { + remainder: t.slice(i.length), + }), + }), + u( + ` Static transition to ${e} found (partial match)` + ); + e = !0; + } + e || u(' No partial static transition found'); + } + if ('\0' !== i) + for (const [e, { to: t, reducer: r }] of A.dynamics) + b(S, e, a, i) && + (s.push({ + node: t, + state: void 0 !== r ? b(k, r, a, i) : a, + }), + u(` Dynamic transition to ${t} found (via ${e})`)); + } + if (0 === s.length && '\0' === i && 1 === t.length) + return [{ node: 0, state: h }]; + if (0 === s.length) + throw new c( + t, + A.filter(({ node: e }) => 2 !== e).map(({ state: e }) => ({ + usage: e.candidateUsage, + reason: null, + })) + ); + if (s.every(({ node: e }) => 2 === e)) + throw new c( + t, + s.map(({ state: e }) => ({ + usage: e.candidateUsage, + reason: e.errorMessage, + })) + ); + A = I(s); + } + if (A.length > 0) { + u(' Results:'); + for (const e of A) + u(` - ${e.node} -> ${JSON.stringify(e.state)}`); + } else u(' No results'); + return A; + } + function C(e, t) { + if (null !== t.selectedIndex) return !0; + if (Object.prototype.hasOwnProperty.call(e.statics, '\0')) + for (const { to: t } of e.statics['\0']) if (1 === t) return !0; + return !1; + } + function f(e, t) { + return (function (e, t) { + const r = t.filter((e) => null !== e.selectedIndex); + if (0 === r.length) throw new Error(); + let A = 0; + for (const e of r) e.path.length > A && (A = e.path.length); + const n = r.filter((e) => e.path.length === A), + o = (e) => + e.positionals.filter(({ extra: e }) => !e).length + + e.options.length, + i = n.map((e) => ({ state: e, positionalCount: o(e) })); + let s = 0; + for (const { positionalCount: e } of i) e > s && (s = e); + const a = (function (e) { + const t = [], + r = []; + for (const A of e) -1 === A.selectedIndex ? r.push(A) : t.push(A); + r.length > 0 && + t.push( + Object.assign(Object.assign({}, h), { + path: E(...r.map((e) => e.path)), + options: r.reduce((e, t) => e.concat(t.options), []), + }) + ); + return t; + })( + i + .filter(({ positionalCount: e }) => e === s) + .map(({ state: e }) => e) + ); + if (a.length > 1) + throw new g( + e, + a.map((e) => e.candidateUsage) + ); + return a[0]; + })( + t, + d(e, [...t, '\0']).map(({ state: e }) => e) + ); + } + function I(e) { + let t = 0; + for (const { state: r } of e) + r.path.length > t && (t = r.path.length); + return e.filter(({ state: e }) => e.path.length === t); + } + function E(e, t, ...r) { + return void 0 === t + ? Array.from(e) + : E( + e.filter((e, r) => e === t[r]), + ...r + ); + } + function B(e) { + return 1 === e || 2 === e; + } + function y(e, t = 0) { + return { + to: B(e.to) ? e.to : e.to > 2 ? e.to + t - 2 : e.to + t, + reducer: e.reducer, + }; + } + function m(e, t = 0) { + const r = { dynamics: [], shortcuts: [], statics: {} }; + for (const [A, n] of e.dynamics) r.dynamics.push([A, y(n, t)]); + for (const A of e.shortcuts) r.shortcuts.push(y(A, t)); + for (const [A, n] of Object.entries(e.statics)) + r.statics[A] = n.map((e) => y(e, t)); + return r; + } + function w(e, t, r, A, n) { + e.nodes[t].dynamics.push([r, { to: A, reducer: n }]); + } + function Q(e, t, r, A) { + e.nodes[t].shortcuts.push({ to: r, reducer: A }); + } + function D(e, t, r, A, n) { + (Object.prototype.hasOwnProperty.call(e.nodes[t].statics, r) + ? e.nodes[t].statics[r] + : (e.nodes[t].statics[r] = []) + ).push({ to: A, reducer: n }); + } + function b(e, t, r, A) { + if (Array.isArray(t)) { + const [n, ...o] = t; + return e[n](r, A, ...o); + } + return e[t](r, A); + } + function v(e, t) { + const r = Array.isArray(e) ? S[e[0]] : S[e]; + if (void 0 === r.suggest) return null; + const A = Array.isArray(e) ? e.slice(1) : []; + return r.suggest(t, ...A); + } + const S = { + always: () => !0, + isOptionLike: (e, t) => !e.ignoreOptions && t.startsWith('-'), + isNotOptionLike: (e, t) => e.ignoreOptions || !t.startsWith('-'), + isOption: (e, t, r, A) => !e.ignoreOptions && t === r, + isBatchOption: (e, t, r) => + !e.ignoreOptions && + o.test(t) && + [...t.slice(1)].every((e) => r.includes('-' + e)), + isBoundOption: (e, t, r, A) => { + const o = t.match(i); + return ( + !e.ignoreOptions && + !!o && + n.test(o[1]) && + r.includes(o[1]) && + A.filter((e) => e.names.includes(o[1])).every( + (e) => e.allowBinding + ) + ); + }, + isNegatedOption: (e, t, r) => + !e.ignoreOptions && t === '--no-' + r.slice(2), + isHelp: (e, t) => !e.ignoreOptions && A.test(t), + isUnsupportedOption: (e, t, r) => + !e.ignoreOptions && + t.startsWith('-') && + n.test(t) && + !r.includes(t), + isInvalidOption: (e, t) => + !e.ignoreOptions && t.startsWith('-') && !n.test(t), + }; + S.isOption.suggest = (e, t, r = !0) => (r ? null : [t]); + const k = { + setCandidateUsage: (e, t, r) => + Object.assign(Object.assign({}, e), { candidateUsage: r }), + setSelectedIndex: (e, t, r) => + Object.assign(Object.assign({}, e), { selectedIndex: r }), + pushBatch: (e, t) => + Object.assign(Object.assign({}, e), { + options: e.options.concat( + [...t.slice(1)].map((e) => ({ name: '-' + e, value: !0 })) + ), + }), + pushBound: (e, t) => { + const [, r, A] = t.match(i); + return Object.assign(Object.assign({}, e), { + options: e.options.concat({ name: r, value: A }), + }); + }, + pushPath: (e, t) => + Object.assign(Object.assign({}, e), { path: e.path.concat(t) }), + pushPositional: (e, t) => + Object.assign(Object.assign({}, e), { + positionals: e.positionals.concat({ value: t, extra: !1 }), + }), + pushExtra: (e, t) => + Object.assign(Object.assign({}, e), { + positionals: e.positionals.concat({ value: t, extra: !0 }), + }), + pushExtraNoLimits: (e, t) => + Object.assign(Object.assign({}, e), { + positionals: e.positionals.concat({ value: t, extra: N }), + }), + pushTrue: (e, t, r = t) => + Object.assign(Object.assign({}, e), { + options: e.options.concat({ name: t, value: !0 }), + }), + pushFalse: (e, t, r = t) => + Object.assign(Object.assign({}, e), { + options: e.options.concat({ name: r, value: !1 }), + }), + pushUndefined: (e, t) => + Object.assign(Object.assign({}, e), { + options: e.options.concat({ name: t, value: void 0 }), + }), + pushStringValue: (e, t) => { + var r; + const A = Object.assign(Object.assign({}, e), { + options: [...e.options], + }), + n = e.options[e.options.length - 1]; + return ( + (n.value = (null !== (r = n.value) && void 0 !== r + ? r + : [] + ).concat([t])), + A + ); + }, + setStringValue: (e, t) => { + const r = Object.assign(Object.assign({}, e), { + options: [...e.options], + }); + return (e.options[e.options.length - 1].value = t), r; + }, + inhibateOptions: (e) => + Object.assign(Object.assign({}, e), { ignoreOptions: !0 }), + useHelp: (e, t, r) => { + const [, n, o] = t.match(A); + return void 0 !== o + ? Object.assign(Object.assign({}, e), { + options: [ + { name: '-c', value: String(r) }, + { name: '-i', value: o }, + ], + }) + : Object.assign(Object.assign({}, e), { + options: [{ name: '-c', value: String(r) }], + }); + }, + setError: (e, t, r) => + '\0' === t + ? Object.assign(Object.assign({}, e), { errorMessage: r + '.' }) + : Object.assign(Object.assign({}, e), { + errorMessage: `${r} ("${t}").`, + }), + setOptionArityError: (e, t) => { + const r = e.options[e.options.length - 1]; + return Object.assign(Object.assign({}, e), { + errorMessage: `Not enough arguments to option ${r.name}.`, + }); + }, + }, + N = Symbol(); + class F { + constructor(e, t) { + (this.allOptionNames = []), + (this.arity = { + leading: [], + trailing: [], + extra: [], + proxy: !1, + }), + (this.options = []), + (this.paths = []), + (this.cliIndex = e), + (this.cliOpts = t); + } + addPath(e) { + this.paths.push(e); + } + setArity({ + leading: e = this.arity.leading, + trailing: t = this.arity.trailing, + extra: r = this.arity.extra, + proxy: A = this.arity.proxy, + }) { + Object.assign(this.arity, { + leading: e, + trailing: t, + extra: r, + proxy: A, + }); + } + addPositional({ name: e = 'arg', required: t = !0 } = {}) { + if (!t && this.arity.extra === N) + throw new Error( + 'Optional parameters cannot be declared when using .rest() or .proxy()' + ); + if (!t && this.arity.trailing.length > 0) + throw new Error( + 'Optional parameters cannot be declared after the required trailing positional arguments' + ); + t || this.arity.extra === N + ? this.arity.extra !== N && 0 === this.arity.extra.length + ? this.arity.leading.push(e) + : this.arity.trailing.push(e) + : this.arity.extra.push(e); + } + addRest({ name: e = 'arg', required: t = 0 } = {}) { + if (this.arity.extra === N) + throw new Error( + 'Infinite lists cannot be declared multiple times in the same command' + ); + if (this.arity.trailing.length > 0) + throw new Error( + 'Infinite lists cannot be declared after the required trailing positional arguments' + ); + for (let r = 0; r < t; ++r) this.addPositional({ name: e }); + this.arity.extra = N; + } + addProxy({ required: e = 0 } = {}) { + this.addRest({ required: e }), (this.arity.proxy = !0); + } + addOption({ + names: e, + description: t, + arity: r = 0, + hidden: A = !1, + allowBinding: n = !0, + }) { + if (!n && r > 1) + throw new Error( + 'The arity cannot be higher than 1 when the option only supports the --arg=value syntax' + ); + if (!Number.isInteger(r)) + throw new Error('The arity must be an integer, got ' + r); + if (r < 0) throw new Error('The arity must be positive, got ' + r); + this.allOptionNames.push(...e), + this.options.push({ + names: e, + description: t, + arity: r, + hidden: A, + allowBinding: n, + }); + } + setContext(e) { + this.context = e; + } + usage({ detailed: e = !0, inlineOptions: t = !0 } = {}) { + const r = [this.cliOpts.binaryName], + A = []; + if ((this.paths.length > 0 && r.push(...this.paths[0]), e)) { + for (const { + names: e, + arity: n, + hidden: o, + description: i, + } of this.options) { + if (o) continue; + const s = []; + for (let e = 0; e < n; ++e) s.push(' #' + e); + const a = `${e.join(',')}${s.join('')}`; + !t && i + ? A.push({ definition: a, description: i }) + : r.push(`[${a}]`); + } + r.push(...this.arity.leading.map((e) => `<${e}>`)), + this.arity.extra === N + ? r.push('...') + : r.push(...this.arity.extra.map((e) => `[${e}]`)), + r.push(...this.arity.trailing.map((e) => `<${e}>`)); + } + return { usage: r.join(' '), options: A }; + } + compile() { + if (void 0 === this.context) + throw new Error('Assertion failed: No context attached'); + const e = { + nodes: [ + { dynamics: [], shortcuts: [], statics: {} }, + { dynamics: [], shortcuts: [], statics: {} }, + { dynamics: [], shortcuts: [], statics: {} }, + ], + }; + let t = 0; + (t = p(e, { dynamics: [], shortcuts: [], statics: {} })), + D(e, 0, '', t, ['setCandidateUsage', this.usage().usage]); + const r = this.arity.proxy ? 'always' : 'isNotOptionLike', + A = this.paths.length > 0 ? this.paths : [[]]; + for (const n of A) { + let A = t; + if (n.length > 0) { + const t = p(e, { dynamics: [], shortcuts: [], statics: {} }); + Q(e, A, t), this.registerOptions(e, t), (A = t); + } + for (let t = 0; t < n.length; ++t) { + const r = p(e, { dynamics: [], shortcuts: [], statics: {} }); + D(e, A, n[t], r, 'pushPath'), (A = r); + } + if (this.arity.leading.length > 0 || !this.arity.proxy) { + const t = p(e, { dynamics: [], shortcuts: [], statics: {} }); + w(e, A, 'isHelp', t, ['useHelp', this.cliIndex]), + D(e, t, '\0', 1, ['setSelectedIndex', -1]), + this.registerOptions(e, A); + } + this.arity.leading.length > 0 && + D(e, A, '\0', 2, [ + 'setError', + 'Not enough positional arguments', + ]); + let o = A; + for (let t = 0; t < this.arity.leading.length; ++t) { + const r = p(e, { dynamics: [], shortcuts: [], statics: {} }); + this.arity.proxy || this.registerOptions(e, r), + (this.arity.trailing.length > 0 || + t + 1 !== this.arity.leading.length) && + D(e, r, '\0', 2, [ + 'setError', + 'Not enough positional arguments', + ]), + w(e, o, 'isNotOptionLike', r, 'pushPositional'), + (o = r); + } + let i = o; + if (this.arity.extra === N || this.arity.extra.length > 0) { + const t = p(e, { dynamics: [], shortcuts: [], statics: {} }); + if ((Q(e, o, t), this.arity.extra === N)) { + const A = p(e, { dynamics: [], shortcuts: [], statics: {} }); + this.arity.proxy || this.registerOptions(e, A), + w(e, o, r, A, 'pushExtraNoLimits'), + w(e, A, r, A, 'pushExtraNoLimits'), + Q(e, A, t); + } else + for (let A = 0; A < this.arity.extra.length; ++A) { + const A = p(e, { + dynamics: [], + shortcuts: [], + statics: {}, + }); + this.arity.proxy || this.registerOptions(e, A), + w(e, i, r, A, 'pushExtra'), + Q(e, A, t), + (i = A); + } + i = t; + } + this.arity.trailing.length > 0 && + D(e, i, '\0', 2, [ + 'setError', + 'Not enough positional arguments', + ]); + let s = i; + for (let t = 0; t < this.arity.trailing.length; ++t) { + const r = p(e, { dynamics: [], shortcuts: [], statics: {} }); + this.arity.proxy || this.registerOptions(e, r), + t + 1 < this.arity.trailing.length && + D(e, r, '\0', 2, [ + 'setError', + 'Not enough positional arguments', + ]), + w(e, s, 'isNotOptionLike', r, 'pushPositional'), + (s = r); + } + w(e, s, r, 2, ['setError', 'Extraneous positional argument']), + D(e, s, '\0', 1, ['setSelectedIndex', this.cliIndex]); + } + return { machine: e, context: this.context }; + } + registerOptions(e, t) { + w(e, t, ['isOption', '--'], t, 'inhibateOptions'), + w(e, t, ['isBatchOption', this.allOptionNames], t, 'pushBatch'), + w( + e, + t, + ['isBoundOption', this.allOptionNames, this.options], + t, + 'pushBound' + ), + w(e, t, ['isUnsupportedOption', this.allOptionNames], 2, [ + 'setError', + 'Unsupported option name', + ]), + w(e, t, ['isInvalidOption'], 2, [ + 'setError', + 'Invalid option name', + ]); + for (const r of this.options) { + const A = r.names.reduce( + (e, t) => (t.length > e.length ? t : e), + '' + ); + if (0 === r.arity) + for (const n of r.names) + w(e, t, ['isOption', n, r.hidden || n !== A], t, 'pushTrue'), + n.startsWith('--') && + !n.startsWith('--no-') && + w(e, t, ['isNegatedOption', n], t, ['pushFalse', n]); + else { + let n = p(e, { dynamics: [], shortcuts: [], statics: {} }); + for (const o of r.names) + w( + e, + t, + ['isOption', o, r.hidden || o !== A], + n, + 'pushUndefined' + ); + for (let t = 0; t < r.arity; ++t) { + const t = p(e, { dynamics: [], shortcuts: [], statics: {} }); + D(e, n, '\0', 2, 'setOptionArityError'), + w(e, n, 'isOptionLike', 2, 'setOptionArityError'); + w( + e, + n, + 'isNotOptionLike', + t, + 1 === r.arity ? 'setStringValue' : 'pushStringValue' + ), + (n = t); + } + Q(e, n, t); + } + } + } + } + class K { + constructor({ binaryName: e = '...' } = {}) { + (this.builders = []), (this.opts = { binaryName: e }); + } + static build(e, t = {}) { + return new K(t).commands(e).compile(); + } + getBuilderByIndex(e) { + if (!(e >= 0 && e < this.builders.length)) + throw new Error( + `Assertion failed: Out-of-bound command index (${e})` + ); + return this.builders[e]; + } + commands(e) { + for (const t of e) t(this.command()); + return this; + } + command() { + const e = new F(this.builders.length, this.opts); + return this.builders.push(e), e; + } + compile() { + const e = [], + t = []; + for (const r of this.builders) { + const { machine: A, context: n } = r.compile(); + e.push(A), t.push(n); + } + const r = (function (e) { + const t = { + nodes: [ + { dynamics: [], shortcuts: [], statics: {} }, + { dynamics: [], shortcuts: [], statics: {} }, + { dynamics: [], shortcuts: [], statics: {} }, + ], + }, + r = []; + let A = t.nodes.length; + for (const n of e) { + r.push(A); + for (let e = 0; e < n.nodes.length; ++e) + B(e) || t.nodes.push(m(n.nodes[e], A)); + A += n.nodes.length - 2; + } + for (const e of r) Q(t, 0, e); + return t; + })(e); + return ( + (function (e) { + const t = new Set(), + r = (A) => { + if (t.has(A)) return; + t.add(A); + const n = e.nodes[A]; + for (const e of Object.values(n.statics)) + for (const { to: t } of e) r(t); + for (const [, { to: e }] of n.dynamics) r(e); + for (const { to: e } of n.shortcuts) r(e); + const o = new Set(n.shortcuts.map(({ to: e }) => e)); + for (; n.shortcuts.length > 0; ) { + const { to: t } = n.shortcuts.shift(), + r = e.nodes[t]; + for (const [e, t] of Object.entries(r.statics)) { + let r = Object.prototype.hasOwnProperty.call( + n.statics, + e + ) + ? n.statics[e] + : (n.statics[e] = []); + for (const e of t) + r.some(({ to: t }) => e.to === t) || r.push(e); + } + for (const [e, t] of r.dynamics) + n.dynamics.some( + ([r, { to: A }]) => e === r && t.to === A + ) || n.dynamics.push([e, t]); + for (const e of r.shortcuts) + o.has(e.to) || (n.shortcuts.push(e), o.add(e.to)); + } + }; + r(0); + })(r), + { + machine: r, + contexts: t, + process: (e) => f(r, e), + suggest: (e, t) => + (function (e, t, r) { + const A = r && t.length > 0 ? [''] : [], + n = d(e, t, r), + o = [], + i = new Set(), + s = (t, r, A = !0) => { + let n = [r]; + for (; n.length > 0; ) { + const r = n; + n = []; + for (const o of r) { + const r = e.nodes[o], + i = Object.keys(r.statics); + for (const e of Object.keys(r.statics)) { + const e = i[0]; + for (const { to: o, reducer: i } of r.statics[e]) + 'pushPath' === i && (A || t.push(e), n.push(o)); + } + } + A = !1; + } + const s = JSON.stringify(t); + i.has(s) || (o.push(t), i.add(s)); + }; + for (const { node: t, state: r } of n) { + if (null !== r.remainder) { + s([r.remainder], t); + continue; + } + const n = e.nodes[t], + o = C(n, r); + for (const [e, r] of Object.entries(n.statics)) + ((o && '\0' !== e) || + (!e.startsWith('-') && + r.some(({ reducer: e }) => 'pushPath' === e))) && + s([...A, e], t); + if (o) + for (const [e, { to: o }] of n.dynamics) { + if (2 === o) continue; + const n = v(e, r); + if (null !== n) for (const e of n) s([...A, e], t); + } + } + return [...o].sort(); + })(r, e, t), + } + ); + } + } + class M { + constructor() { + this.help = !1; + } + static getMeta(e) { + const t = e.constructor; + return (t.meta = Object.prototype.hasOwnProperty.call(t, 'meta') + ? t.meta + : { + definitions: [], + transformers: [ + (e, t) => { + for (const { name: r, value: A } of e.options) + ('-h' !== r && '--help' !== r) || (t.help = A); + }, + ], + }); + } + static resolveMeta(e) { + const t = [], + r = []; + for (let A = e; A instanceof M; A = A.__proto__) { + const e = this.getMeta(A); + for (const r of e.definitions) t.push(r); + for (const t of e.transformers) r.push(t); + } + return { definitions: t, transformers: r }; + } + static registerDefinition(e, t) { + this.getMeta(e).definitions.push(t); + } + static registerTransformer(e, t) { + this.getMeta(e).transformers.push(t); + } + static addPath(...e) { + this.Path(...e)(this.prototype, 'execute'); + } + static addOption(e, t) { + t(this.prototype, e); + } + static Path(...e) { + return (t, r) => { + this.registerDefinition(t, (t) => { + t.addPath(e); + }); + }; + } + static Boolean(e, { hidden: t = !1, description: r } = {}) { + return (A, n) => { + const o = e.split(','); + this.registerDefinition(A, (e) => { + e.addOption({ + names: o, + arity: 0, + hidden: t, + allowBinding: !1, + description: r, + }); + }), + this.registerTransformer(A, (e, t) => { + for (const { name: r, value: A } of e.options) + o.includes(r) && (t[n] = A); + }); + }; + } + static Counter(e, { hidden: t = !1, description: r } = {}) { + return (A, n) => { + const o = e.split(','); + this.registerDefinition(A, (e) => { + e.addOption({ + names: o, + arity: 0, + hidden: t, + allowBinding: !1, + description: r, + }); + }), + this.registerTransformer(A, (e, t) => { + var r; + for (const { name: A, value: i } of e.options) + o.includes(A) && + ((null !== (r = t[n]) && void 0 !== r) || (t[n] = 0), + i ? t[n]++ : (t[n] = 0)); + }); + }; + } + static String( + e = {}, + { + arity: t = 1, + tolerateBoolean: r = !1, + hidden: A = !1, + description: n, + } = {} + ) { + return (o, i) => { + if ('string' == typeof e) { + const s = e.split(','); + this.registerDefinition(o, (e) => { + e.addOption({ + names: s, + arity: r ? 0 : t, + hidden: A, + description: n, + }); + }), + this.registerTransformer(o, (e, t) => { + for (const { name: r, value: A } of e.options) + s.includes(r) && (t[i] = A); + }); + } else { + const { name: t = i, required: r = !0 } = e; + this.registerDefinition(o, (e) => { + e.addPositional({ name: t, required: r }); + }), + this.registerTransformer(o, (e, t) => { + for (let A = 0; A < e.positionals.length; ++A) { + if (e.positionals[A].extra === N) continue; + if (r && !0 === e.positionals[A].extra) continue; + if (!r && !1 === e.positionals[A].extra) continue; + const [n] = e.positionals.splice(A, 1); + t[i] = n.value; + break; + } + }); + } + }; + } + static Array( + e, + { arity: t = 1, hidden: r = !1, description: A } = {} + ) { + return (n, o) => { + if (0 === t) + throw new Error( + 'Array options are expected to have at least an arity of 1' + ); + const i = e.split(','); + this.registerDefinition(n, (e) => { + e.addOption({ names: i, arity: t, hidden: r, description: A }); + }), + this.registerTransformer(n, (e, t) => { + for (const { name: r, value: A } of e.options) + i.includes(r) && ((t[o] = t[o] || []), t[o].push(A)); + }); + }; + } + static Rest({ required: e = 0 } = {}) { + return (t, r) => { + this.registerDefinition(t, (t) => { + t.addRest({ name: r, required: e }); + }), + this.registerTransformer(t, (e, t, A) => { + const n = (t) => { + const r = e.positionals[t]; + return ( + r.extra === N || + (!1 === r.extra && t < A.arity.leading.length) + ); + }; + let o = 0; + for (; o < e.positionals.length && n(o); ) o += 1; + t[r] = e.positionals.splice(0, o).map(({ value: e }) => e); + }); + }; + } + static Proxy({ required: e = 0 } = {}) { + return (t, r) => { + this.registerDefinition(t, (t) => { + t.addProxy({ required: e }); + }), + this.registerTransformer(t, (e, t) => { + t[r] = e.positionals.map(({ value: e }) => e); + }); + }; + } + static Usage(e) { + return e; + } + static Schema(e) { + return e; + } + async catch(e) { + throw e; + } + async validateAndExecute() { + const e = this.constructor.schema; + if (void 0 !== e) + try { + await e.validate(this); + } catch (e) { + throw ( + ('ValidationError' === e.name && + (e.clipanion = { type: 'usage' }), + e) + ); + } + const t = await this.execute(); + return void 0 !== t ? t : 0; + } + } + /*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + function R(e, t, r, A) { + var n, + o = arguments.length, + i = + o < 3 + ? t + : null === A + ? (A = Object.getOwnPropertyDescriptor(t, r)) + : A; + if ( + 'object' == typeof Reflect && + 'function' == typeof Reflect.decorate + ) + i = Reflect.decorate(e, t, r, A); + else + for (var s = e.length - 1; s >= 0; s--) + (n = e[s]) && + (i = (o < 3 ? n(i) : o > 3 ? n(t, r, i) : n(t, r)) || i); + return o > 3 && i && Object.defineProperty(t, r, i), i; + } + M.Entries = {}; + class x extends M { + async execute() { + this.context.stdout.write(this.cli.usage(null)); + } + } + R([M.Path('--help'), M.Path('-h')], x.prototype, 'execute', null); + class L extends M { + async execute() { + var e; + this.context.stdout.write( + (null !== (e = this.cli.binaryVersion) && void 0 !== e + ? e + : '') + '\n' + ); + } + } + R([M.Path('--version'), M.Path('-v')], L.prototype, 'execute', null); + const P = { + bold: (e) => `${e}`, + error: (e) => `${e}`, + code: (e) => `${e}`, + }, + O = { bold: (e) => e, error: (e) => e, code: (e) => e }; + function U(e, { format: t, paragraphs: r }) { + return ( + (e = (e = (e = (e = (e = e.replace(/\r\n?/g, '\n')).replace( + /^[\t ]+|[\t ]+$/gm, + '' + )).replace(/^\n+|\n+$/g, '')).replace( + /^-([^\n]*?)\n+/gm, + '-$1\n\n' + )).replace(/\n(\n)?\n*/g, '$1')), + r && + (e = e + .split(/\n/) + .map(function (e) { + let t = e.match(/^[*-][\t ]+(.*)/); + return t + ? t[1] + .match(/(.{1,78})(?: |$)/g) + .map((e, t) => (0 === t ? '- ' : ' ') + e) + .join('\n') + : e.match(/(.{1,80})(?: |$)/g).join('\n'); + }) + .join('\n\n')), + (e = e.replace(/(`+)((?:.|[\n])*?)\1/g, function (e, r, A) { + return t.code(r + A + r); + })) + ? e + '\n' + : '' + ); + } + class T extends M { + constructor(e) { + super(), (this.contexts = e), (this.commands = []); + } + static from(e, t) { + const r = new T(t); + r.path = e.path; + for (const t of e.options) + switch (t.name) { + case '-c': + r.commands.push(Number(t.value)); + break; + case '-i': + r.index = Number(t.value); + } + return r; + } + async execute() { + let e = this.commands; + if ( + (void 0 !== this.index && + this.index >= 0 && + this.index < e.length && + (e = [e[this.index]]), + 0 === e.length) + ) + this.context.stdout.write(this.cli.usage()); + else if (1 === e.length) + this.context.stdout.write( + this.cli.usage(this.contexts[e[0]].commandClass, { + detailed: !0, + }) + ); + else if (e.length > 1) { + this.context.stdout.write( + 'Multiple commands match your selection:\n' + ), + this.context.stdout.write('\n'); + let e = 0; + for (const t of this.commands) + this.context.stdout.write( + this.cli.usage(this.contexts[t].commandClass, { + prefix: (e++ + '. ').padStart(5), + }) + ); + this.context.stdout.write('\n'), + this.context.stdout.write( + 'Run again with -h= to see the longer details of any of those commands.\n' + ); + } + } + } + function j() { + return ( + '0' !== process.env.FORCE_COLOR && + ('1' === process.env.FORCE_COLOR || + !(void 0 === process.stdout || !process.stdout.isTTY)) + ); + } + class Y { + constructor({ + binaryLabel: e, + binaryName: t = '...', + binaryVersion: r, + enableColors: A = j(), + } = {}) { + (this.registrations = new Map()), + (this.builder = new K({ binaryName: t })), + (this.binaryLabel = e), + (this.binaryName = t), + (this.binaryVersion = r), + (this.enableColors = A); + } + static from(e, t = {}) { + const r = new Y(t); + for (const t of e) r.register(t); + return r; + } + register(e) { + const t = this.builder.command(); + this.registrations.set(e, t.cliIndex); + const { definitions: r } = e.resolveMeta(e.prototype); + for (const e of r) e(t); + t.setContext({ commandClass: e }); + } + process(e) { + const { contexts: t, process: r } = this.builder.compile(), + A = r(e); + switch (A.selectedIndex) { + case -1: + return T.from(A, t); + default: { + const { commandClass: e } = t[A.selectedIndex], + r = this.registrations.get(e); + if (void 0 === r) + throw new Error( + 'Assertion failed: Expected the command class to have been registered.' + ); + const n = this.builder.getBuilderByIndex(r), + o = new e(); + o.path = A.path; + const { transformers: i } = e.resolveMeta(e.prototype); + for (const e of i) e(A, o, n); + return o; + } + } + } + async run(e, t) { + let r, A; + if (Array.isArray(e)) + try { + r = this.process(e); + } catch (e) { + return t.stdout.write(this.error(e)), 1; + } + else r = e; + if (r.help) + return t.stdout.write(this.usage(r, { detailed: !0 })), 0; + (r.context = t), + (r.cli = { + binaryLabel: this.binaryLabel, + binaryName: this.binaryName, + binaryVersion: this.binaryVersion, + enableColors: this.enableColors, + definitions: () => this.definitions(), + error: (e, t) => this.error(e, t), + process: (e) => this.process(e), + run: (e, r) => + this.run(e, Object.assign(Object.assign({}, t), r)), + usage: (e, t) => this.usage(e, t), + }); + try { + A = await r + .validateAndExecute() + .catch((e) => r.catch(e).then(() => 0)); + } catch (e) { + return t.stdout.write(this.error(e, { command: r })), 1; + } + return A; + } + async runExit(e, t) { + process.exitCode = await this.run(e, t); + } + suggest(e, t) { + const { + contexts: r, + process: A, + suggest: n, + } = this.builder.compile(); + return n(e, t); + } + definitions({ colored: e = !1 } = {}) { + const t = []; + for (const [r, A] of this.registrations) { + if (void 0 === r.usage) continue; + const { usage: n } = this.getUsageByIndex(A, { detailed: !1 }), + { usage: o, options: i } = this.getUsageByIndex(A, { + detailed: !0, + inlineOptions: !1, + }), + s = + void 0 !== r.usage.category + ? U(r.usage.category, { + format: this.format(e), + paragraphs: !1, + }) + : void 0, + a = + void 0 !== r.usage.description + ? U(r.usage.description, { + format: this.format(e), + paragraphs: !1, + }) + : void 0, + c = + void 0 !== r.usage.details + ? U(r.usage.details, { + format: this.format(e), + paragraphs: !0, + }) + : void 0, + g = + void 0 !== r.usage.examples + ? r.usage.examples.map(([t, r]) => [ + U(t, { format: this.format(e), paragraphs: !1 }), + r.replace(/\$0/g, this.binaryName), + ]) + : void 0; + t.push({ + path: n, + usage: o, + category: s, + description: a, + details: c, + examples: g, + options: i, + }); + } + return t; + } + usage( + e = null, + { colored: t, detailed: r = !1, prefix: A = '$ ' } = {} + ) { + const n = null !== e && void 0 === e.getMeta ? e.constructor : e; + let o = ''; + if (n) + if (r) { + const { + description: e = '', + details: r = '', + examples: i = [], + } = n.usage || {}; + '' !== e && + ((o += U(e, { + format: this.format(t), + paragraphs: !1, + }).replace(/^./, (e) => e.toUpperCase())), + (o += '\n')), + ('' !== r || i.length > 0) && + ((o += this.format(t).bold('Usage:') + '\n'), (o += '\n')); + const { usage: s, options: a } = this.getUsageByRegistration( + n, + { inlineOptions: !1 } + ); + if (((o += `${this.format(t).bold(A)}${s}\n`), a.length > 0)) { + (o += '\n'), (o += P.bold('Options:') + '\n'); + const e = a.reduce( + (e, t) => Math.max(e, t.definition.length), + 0 + ); + o += '\n'; + for (const { definition: r, description: A } of a) + o += ` ${r.padEnd(e)} ${U(A, { + format: this.format(t), + paragraphs: !1, + })}`; + } + if ( + ('' !== r && + ((o += '\n'), + (o += this.format(t).bold('Details:') + '\n'), + (o += '\n'), + (o += U(r, { format: this.format(t), paragraphs: !0 }))), + i.length > 0) + ) { + (o += '\n'), (o += this.format(t).bold('Examples:') + '\n'); + for (let [e, r] of i) + (o += '\n'), + (o += U(e, { format: this.format(t), paragraphs: !1 })), + (o += + r + .replace(/^/m, ' ' + this.format(t).bold(A)) + .replace(/\$0/g, this.binaryName) + '\n'); + } + } else { + const { usage: e } = this.getUsageByRegistration(n); + o += `${this.format(t).bold(A)}${e}\n`; + } + else { + const e = new Map(); + for (const [r, A] of this.registrations.entries()) { + if (void 0 === r.usage) continue; + const n = + void 0 !== r.usage.category + ? U(r.usage.category, { + format: this.format(t), + paragraphs: !1, + }) + : null; + let o = e.get(n); + void 0 === o && e.set(n, (o = [])); + const { usage: i } = this.getUsageByIndex(A); + o.push({ commandClass: r, usage: i }); + } + const r = Array.from(e.keys()).sort((e, t) => + null === e + ? -1 + : null === t + ? 1 + : e.localeCompare(t, 'en', { + usage: 'sort', + caseFirst: 'upper', + }) + ), + n = void 0 !== this.binaryLabel, + i = void 0 !== this.binaryVersion; + n || i + ? ((o += + n && i + ? this.format(t).bold( + `${this.binaryLabel} - ${this.binaryVersion}` + ) + '\n\n' + : n + ? this.format(t).bold('' + this.binaryLabel) + '\n' + : this.format(t).bold('' + this.binaryVersion) + '\n'), + (o += ` ${this.format(t).bold(A)}${ + this.binaryName + } \n`)) + : (o += `${this.format(t).bold(A)}${ + this.binaryName + } \n`); + for (let A of r) { + const r = e + .get(A) + .slice() + .sort((e, t) => + e.usage.localeCompare(t.usage, 'en', { + usage: 'sort', + caseFirst: 'upper', + }) + ), + n = null !== A ? A.trim() : 'Where is one of'; + (o += '\n'), (o += this.format(t).bold(n + ':') + '\n'); + for (let { commandClass: e, usage: A } of r) { + const r = e.usage.description || 'undocumented'; + (o += '\n'), + (o += ` ${this.format(t).bold(A)}\n`), + (o += + ' ' + + U(r, { format: this.format(t), paragraphs: !1 })); + } + } + (o += '\n'), + (o += U( + 'You can also print more details about any of these commands by calling them after adding the `-h,--help` flag right after the command name.', + { format: this.format(t), paragraphs: !0 } + )); + } + return o; + } + error(e, { colored: t, command: r = null } = {}) { + e instanceof Error || + (e = new Error( + `Execution failed with a non-error rejection (rejected value: ${JSON.stringify( + e + )})` + )); + let A = '', + n = e.name.replace(/([a-z])([A-Z])/g, '$1 $2'); + 'Error' === n && (n = 'Internal Error'), + (A += `${this.format(t).error(n)}: ${e.message}\n`); + const o = e.clipanion; + return ( + void 0 !== o + ? 'usage' === o.type && ((A += '\n'), (A += this.usage(r))) + : e.stack && (A += e.stack.replace(/^.*\n/, '') + '\n'), + A + ); + } + getUsageByRegistration(e, t) { + const r = this.registrations.get(e); + if (void 0 === r) + throw new Error('Assertion failed: Unregistered command'); + return this.getUsageByIndex(r, t); + } + getUsageByIndex(e, t) { + return this.builder.getBuilderByIndex(e).usage(t); + } + format(e = this.enableColors) { + return e ? P : O; + } + } + (Y.defaultContext = { + stdin: process.stdin, + stdout: process.stdout, + stderr: process.stderr, + }), + (M.Entries.Help = x), + (M.Entries.Version = L); + }, + 15751: (e, t, r) => { + 'use strict'; + const A = r(92413).PassThrough, + n = r(65007); + e.exports = (e) => { + if (!e || !e.pipe) + throw new TypeError( + 'Parameter `response` must be a response stream.' + ); + const t = new A(); + return n(e, t), e.pipe(t); + }; + }, + 15311: (e, t, r) => { + const A = r(93300), + n = {}; + for (const e of Object.keys(A)) n[A[e]] = e; + const o = { + rgb: { channels: 3, labels: 'rgb' }, + hsl: { channels: 3, labels: 'hsl' }, + hsv: { channels: 3, labels: 'hsv' }, + hwb: { channels: 3, labels: 'hwb' }, + cmyk: { channels: 4, labels: 'cmyk' }, + xyz: { channels: 3, labels: 'xyz' }, + lab: { channels: 3, labels: 'lab' }, + lch: { channels: 3, labels: 'lch' }, + hex: { channels: 1, labels: ['hex'] }, + keyword: { channels: 1, labels: ['keyword'] }, + ansi16: { channels: 1, labels: ['ansi16'] }, + ansi256: { channels: 1, labels: ['ansi256'] }, + hcg: { channels: 3, labels: ['h', 'c', 'g'] }, + apple: { channels: 3, labels: ['r16', 'g16', 'b16'] }, + gray: { channels: 1, labels: ['gray'] }, + }; + e.exports = o; + for (const e of Object.keys(o)) { + if (!('channels' in o[e])) + throw new Error('missing channels property: ' + e); + if (!('labels' in o[e])) + throw new Error('missing channel labels property: ' + e); + if (o[e].labels.length !== o[e].channels) + throw new Error('channel and label counts mismatch: ' + e); + const { channels: t, labels: r } = o[e]; + delete o[e].channels, + delete o[e].labels, + Object.defineProperty(o[e], 'channels', { value: t }), + Object.defineProperty(o[e], 'labels', { value: r }); + } + (o.rgb.hsl = function (e) { + const t = e[0] / 255, + r = e[1] / 255, + A = e[2] / 255, + n = Math.min(t, r, A), + o = Math.max(t, r, A), + i = o - n; + let s, a; + o === n + ? (s = 0) + : t === o + ? (s = (r - A) / i) + : r === o + ? (s = 2 + (A - t) / i) + : A === o && (s = 4 + (t - r) / i), + (s = Math.min(60 * s, 360)), + s < 0 && (s += 360); + const c = (n + o) / 2; + return ( + (a = o === n ? 0 : c <= 0.5 ? i / (o + n) : i / (2 - o - n)), + [s, 100 * a, 100 * c] + ); + }), + (o.rgb.hsv = function (e) { + let t, r, A, n, o; + const i = e[0] / 255, + s = e[1] / 255, + a = e[2] / 255, + c = Math.max(i, s, a), + g = c - Math.min(i, s, a), + l = function (e) { + return (c - e) / 6 / g + 0.5; + }; + return ( + 0 === g + ? ((n = 0), (o = 0)) + : ((o = g / c), + (t = l(i)), + (r = l(s)), + (A = l(a)), + i === c + ? (n = A - r) + : s === c + ? (n = 1 / 3 + t - A) + : a === c && (n = 2 / 3 + r - t), + n < 0 ? (n += 1) : n > 1 && (n -= 1)), + [360 * n, 100 * o, 100 * c] + ); + }), + (o.rgb.hwb = function (e) { + const t = e[0], + r = e[1]; + let A = e[2]; + const n = o.rgb.hsl(e)[0], + i = (1 / 255) * Math.min(t, Math.min(r, A)); + return ( + (A = 1 - (1 / 255) * Math.max(t, Math.max(r, A))), + [n, 100 * i, 100 * A] + ); + }), + (o.rgb.cmyk = function (e) { + const t = e[0] / 255, + r = e[1] / 255, + A = e[2] / 255, + n = Math.min(1 - t, 1 - r, 1 - A); + return [ + 100 * ((1 - t - n) / (1 - n) || 0), + 100 * ((1 - r - n) / (1 - n) || 0), + 100 * ((1 - A - n) / (1 - n) || 0), + 100 * n, + ]; + }), + (o.rgb.keyword = function (e) { + const t = n[e]; + if (t) return t; + let r, + o = 1 / 0; + for (const t of Object.keys(A)) { + const n = A[t], + a = + ((s = n), + ((i = e)[0] - s[0]) ** 2 + + (i[1] - s[1]) ** 2 + + (i[2] - s[2]) ** 2); + a < o && ((o = a), (r = t)); + } + var i, s; + return r; + }), + (o.keyword.rgb = function (e) { + return A[e]; + }), + (o.rgb.xyz = function (e) { + let t = e[0] / 255, + r = e[1] / 255, + A = e[2] / 255; + (t = t > 0.04045 ? ((t + 0.055) / 1.055) ** 2.4 : t / 12.92), + (r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92), + (A = A > 0.04045 ? ((A + 0.055) / 1.055) ** 2.4 : A / 12.92); + return [ + 100 * (0.4124 * t + 0.3576 * r + 0.1805 * A), + 100 * (0.2126 * t + 0.7152 * r + 0.0722 * A), + 100 * (0.0193 * t + 0.1192 * r + 0.9505 * A), + ]; + }), + (o.rgb.lab = function (e) { + const t = o.rgb.xyz(e); + let r = t[0], + A = t[1], + n = t[2]; + (r /= 95.047), + (A /= 100), + (n /= 108.883), + (r = r > 0.008856 ? r ** (1 / 3) : 7.787 * r + 16 / 116), + (A = A > 0.008856 ? A ** (1 / 3) : 7.787 * A + 16 / 116), + (n = n > 0.008856 ? n ** (1 / 3) : 7.787 * n + 16 / 116); + return [116 * A - 16, 500 * (r - A), 200 * (A - n)]; + }), + (o.hsl.rgb = function (e) { + const t = e[0] / 360, + r = e[1] / 100, + A = e[2] / 100; + let n, o, i; + if (0 === r) return (i = 255 * A), [i, i, i]; + n = A < 0.5 ? A * (1 + r) : A + r - A * r; + const s = 2 * A - n, + a = [0, 0, 0]; + for (let e = 0; e < 3; e++) + (o = t + (1 / 3) * -(e - 1)), + o < 0 && o++, + o > 1 && o--, + (i = + 6 * o < 1 + ? s + 6 * (n - s) * o + : 2 * o < 1 + ? n + : 3 * o < 2 + ? s + (n - s) * (2 / 3 - o) * 6 + : s), + (a[e] = 255 * i); + return a; + }), + (o.hsl.hsv = function (e) { + const t = e[0]; + let r = e[1] / 100, + A = e[2] / 100, + n = r; + const o = Math.max(A, 0.01); + (A *= 2), (r *= A <= 1 ? A : 2 - A), (n *= o <= 1 ? o : 2 - o); + return [ + t, + 100 * (0 === A ? (2 * n) / (o + n) : (2 * r) / (A + r)), + 100 * ((A + r) / 2), + ]; + }), + (o.hsv.rgb = function (e) { + const t = e[0] / 60, + r = e[1] / 100; + let A = e[2] / 100; + const n = Math.floor(t) % 6, + o = t - Math.floor(t), + i = 255 * A * (1 - r), + s = 255 * A * (1 - r * o), + a = 255 * A * (1 - r * (1 - o)); + switch (((A *= 255), n)) { + case 0: + return [A, a, i]; + case 1: + return [s, A, i]; + case 2: + return [i, A, a]; + case 3: + return [i, s, A]; + case 4: + return [a, i, A]; + case 5: + return [A, i, s]; + } + }), + (o.hsv.hsl = function (e) { + const t = e[0], + r = e[1] / 100, + A = e[2] / 100, + n = Math.max(A, 0.01); + let o, i; + i = (2 - r) * A; + const s = (2 - r) * n; + return ( + (o = r * n), + (o /= s <= 1 ? s : 2 - s), + (o = o || 0), + (i /= 2), + [t, 100 * o, 100 * i] + ); + }), + (o.hwb.rgb = function (e) { + const t = e[0] / 360; + let r = e[1] / 100, + A = e[2] / 100; + const n = r + A; + let o; + n > 1 && ((r /= n), (A /= n)); + const i = Math.floor(6 * t), + s = 1 - A; + (o = 6 * t - i), 0 != (1 & i) && (o = 1 - o); + const a = r + o * (s - r); + let c, g, l; + switch (i) { + default: + case 6: + case 0: + (c = s), (g = a), (l = r); + break; + case 1: + (c = a), (g = s), (l = r); + break; + case 2: + (c = r), (g = s), (l = a); + break; + case 3: + (c = r), (g = a), (l = s); + break; + case 4: + (c = a), (g = r), (l = s); + break; + case 5: + (c = s), (g = r), (l = a); + } + return [255 * c, 255 * g, 255 * l]; + }), + (o.cmyk.rgb = function (e) { + const t = e[0] / 100, + r = e[1] / 100, + A = e[2] / 100, + n = e[3] / 100; + return [ + 255 * (1 - Math.min(1, t * (1 - n) + n)), + 255 * (1 - Math.min(1, r * (1 - n) + n)), + 255 * (1 - Math.min(1, A * (1 - n) + n)), + ]; + }), + (o.xyz.rgb = function (e) { + const t = e[0] / 100, + r = e[1] / 100, + A = e[2] / 100; + let n, o, i; + return ( + (n = 3.2406 * t + -1.5372 * r + -0.4986 * A), + (o = -0.9689 * t + 1.8758 * r + 0.0415 * A), + (i = 0.0557 * t + -0.204 * r + 1.057 * A), + (n = n > 0.0031308 ? 1.055 * n ** (1 / 2.4) - 0.055 : 12.92 * n), + (o = o > 0.0031308 ? 1.055 * o ** (1 / 2.4) - 0.055 : 12.92 * o), + (i = i > 0.0031308 ? 1.055 * i ** (1 / 2.4) - 0.055 : 12.92 * i), + (n = Math.min(Math.max(0, n), 1)), + (o = Math.min(Math.max(0, o), 1)), + (i = Math.min(Math.max(0, i), 1)), + [255 * n, 255 * o, 255 * i] + ); + }), + (o.xyz.lab = function (e) { + let t = e[0], + r = e[1], + A = e[2]; + (t /= 95.047), + (r /= 100), + (A /= 108.883), + (t = t > 0.008856 ? t ** (1 / 3) : 7.787 * t + 16 / 116), + (r = r > 0.008856 ? r ** (1 / 3) : 7.787 * r + 16 / 116), + (A = A > 0.008856 ? A ** (1 / 3) : 7.787 * A + 16 / 116); + return [116 * r - 16, 500 * (t - r), 200 * (r - A)]; + }), + (o.lab.xyz = function (e) { + let t, r, A; + (r = (e[0] + 16) / 116), (t = e[1] / 500 + r), (A = r - e[2] / 200); + const n = r ** 3, + o = t ** 3, + i = A ** 3; + return ( + (r = n > 0.008856 ? n : (r - 16 / 116) / 7.787), + (t = o > 0.008856 ? o : (t - 16 / 116) / 7.787), + (A = i > 0.008856 ? i : (A - 16 / 116) / 7.787), + (t *= 95.047), + (r *= 100), + (A *= 108.883), + [t, r, A] + ); + }), + (o.lab.lch = function (e) { + const t = e[0], + r = e[1], + A = e[2]; + let n; + (n = (360 * Math.atan2(A, r)) / 2 / Math.PI), n < 0 && (n += 360); + return [t, Math.sqrt(r * r + A * A), n]; + }), + (o.lch.lab = function (e) { + const t = e[0], + r = e[1], + A = (e[2] / 360) * 2 * Math.PI; + return [t, r * Math.cos(A), r * Math.sin(A)]; + }), + (o.rgb.ansi16 = function (e, t = null) { + const [r, A, n] = e; + let i = null === t ? o.rgb.hsv(e)[2] : t; + if (((i = Math.round(i / 50)), 0 === i)) return 30; + let s = + 30 + + ((Math.round(n / 255) << 2) | + (Math.round(A / 255) << 1) | + Math.round(r / 255)); + return 2 === i && (s += 60), s; + }), + (o.hsv.ansi16 = function (e) { + return o.rgb.ansi16(o.hsv.rgb(e), e[2]); + }), + (o.rgb.ansi256 = function (e) { + const t = e[0], + r = e[1], + A = e[2]; + if (t === r && r === A) + return t < 8 + ? 16 + : t > 248 + ? 231 + : Math.round(((t - 8) / 247) * 24) + 232; + return ( + 16 + + 36 * Math.round((t / 255) * 5) + + 6 * Math.round((r / 255) * 5) + + Math.round((A / 255) * 5) + ); + }), + (o.ansi16.rgb = function (e) { + let t = e % 10; + if (0 === t || 7 === t) + return e > 50 && (t += 3.5), (t = (t / 10.5) * 255), [t, t, t]; + const r = 0.5 * (1 + ~~(e > 50)); + return [ + (1 & t) * r * 255, + ((t >> 1) & 1) * r * 255, + ((t >> 2) & 1) * r * 255, + ]; + }), + (o.ansi256.rgb = function (e) { + if (e >= 232) { + const t = 10 * (e - 232) + 8; + return [t, t, t]; + } + let t; + e -= 16; + return [ + (Math.floor(e / 36) / 5) * 255, + (Math.floor((t = e % 36) / 6) / 5) * 255, + ((t % 6) / 5) * 255, + ]; + }), + (o.rgb.hex = function (e) { + const t = ( + ((255 & Math.round(e[0])) << 16) + + ((255 & Math.round(e[1])) << 8) + + (255 & Math.round(e[2])) + ) + .toString(16) + .toUpperCase(); + return '000000'.substring(t.length) + t; + }), + (o.hex.rgb = function (e) { + const t = e.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!t) return [0, 0, 0]; + let r = t[0]; + 3 === t[0].length && + (r = r + .split('') + .map((e) => e + e) + .join('')); + const A = parseInt(r, 16); + return [(A >> 16) & 255, (A >> 8) & 255, 255 & A]; + }), + (o.rgb.hcg = function (e) { + const t = e[0] / 255, + r = e[1] / 255, + A = e[2] / 255, + n = Math.max(Math.max(t, r), A), + o = Math.min(Math.min(t, r), A), + i = n - o; + let s, a; + return ( + (s = i < 1 ? o / (1 - i) : 0), + (a = + i <= 0 + ? 0 + : n === t + ? ((r - A) / i) % 6 + : n === r + ? 2 + (A - t) / i + : 4 + (t - r) / i), + (a /= 6), + (a %= 1), + [360 * a, 100 * i, 100 * s] + ); + }), + (o.hsl.hcg = function (e) { + const t = e[1] / 100, + r = e[2] / 100, + A = r < 0.5 ? 2 * t * r : 2 * t * (1 - r); + let n = 0; + return ( + A < 1 && (n = (r - 0.5 * A) / (1 - A)), [e[0], 100 * A, 100 * n] + ); + }), + (o.hsv.hcg = function (e) { + const t = e[1] / 100, + r = e[2] / 100, + A = t * r; + let n = 0; + return A < 1 && (n = (r - A) / (1 - A)), [e[0], 100 * A, 100 * n]; + }), + (o.hcg.rgb = function (e) { + const t = e[0] / 360, + r = e[1] / 100, + A = e[2] / 100; + if (0 === r) return [255 * A, 255 * A, 255 * A]; + const n = [0, 0, 0], + o = (t % 1) * 6, + i = o % 1, + s = 1 - i; + let a = 0; + switch (Math.floor(o)) { + case 0: + (n[0] = 1), (n[1] = i), (n[2] = 0); + break; + case 1: + (n[0] = s), (n[1] = 1), (n[2] = 0); + break; + case 2: + (n[0] = 0), (n[1] = 1), (n[2] = i); + break; + case 3: + (n[0] = 0), (n[1] = s), (n[2] = 1); + break; + case 4: + (n[0] = i), (n[1] = 0), (n[2] = 1); + break; + default: + (n[0] = 1), (n[1] = 0), (n[2] = s); + } + return ( + (a = (1 - r) * A), + [255 * (r * n[0] + a), 255 * (r * n[1] + a), 255 * (r * n[2] + a)] + ); + }), + (o.hcg.hsv = function (e) { + const t = e[1] / 100, + r = t + (e[2] / 100) * (1 - t); + let A = 0; + return r > 0 && (A = t / r), [e[0], 100 * A, 100 * r]; + }), + (o.hcg.hsl = function (e) { + const t = e[1] / 100, + r = (e[2] / 100) * (1 - t) + 0.5 * t; + let A = 0; + return ( + r > 0 && r < 0.5 + ? (A = t / (2 * r)) + : r >= 0.5 && r < 1 && (A = t / (2 * (1 - r))), + [e[0], 100 * A, 100 * r] + ); + }), + (o.hcg.hwb = function (e) { + const t = e[1] / 100, + r = t + (e[2] / 100) * (1 - t); + return [e[0], 100 * (r - t), 100 * (1 - r)]; + }), + (o.hwb.hcg = function (e) { + const t = e[1] / 100, + r = 1 - e[2] / 100, + A = r - t; + let n = 0; + return A < 1 && (n = (r - A) / (1 - A)), [e[0], 100 * A, 100 * n]; + }), + (o.apple.rgb = function (e) { + return [ + (e[0] / 65535) * 255, + (e[1] / 65535) * 255, + (e[2] / 65535) * 255, + ]; + }), + (o.rgb.apple = function (e) { + return [ + (e[0] / 255) * 65535, + (e[1] / 255) * 65535, + (e[2] / 255) * 65535, + ]; + }), + (o.gray.rgb = function (e) { + return [(e[0] / 100) * 255, (e[0] / 100) * 255, (e[0] / 100) * 255]; + }), + (o.gray.hsl = function (e) { + return [0, 0, e[0]]; + }), + (o.gray.hsv = o.gray.hsl), + (o.gray.hwb = function (e) { + return [0, 100, e[0]]; + }), + (o.gray.cmyk = function (e) { + return [0, 0, 0, e[0]]; + }), + (o.gray.lab = function (e) { + return [e[0], 0, 0]; + }), + (o.gray.hex = function (e) { + const t = 255 & Math.round((e[0] / 100) * 255), + r = ((t << 16) + (t << 8) + t).toString(16).toUpperCase(); + return '000000'.substring(r.length) + r; + }), + (o.rgb.gray = function (e) { + return [((e[0] + e[1] + e[2]) / 3 / 255) * 100]; + }); + }, + 2744: (e, t, r) => { + const A = r(15311), + n = r(78577), + o = {}; + Object.keys(A).forEach((e) => { + (o[e] = {}), + Object.defineProperty(o[e], 'channels', { value: A[e].channels }), + Object.defineProperty(o[e], 'labels', { value: A[e].labels }); + const t = n(e); + Object.keys(t).forEach((r) => { + const A = t[r]; + (o[e][r] = (function (e) { + const t = function (...t) { + const r = t[0]; + if (null == r) return r; + r.length > 1 && (t = r); + const A = e(t); + if ('object' == typeof A) + for (let e = A.length, t = 0; t < e; t++) + A[t] = Math.round(A[t]); + return A; + }; + return 'conversion' in e && (t.conversion = e.conversion), t; + })(A)), + (o[e][r].raw = (function (e) { + const t = function (...t) { + const r = t[0]; + return null == r ? r : (r.length > 1 && (t = r), e(t)); + }; + return 'conversion' in e && (t.conversion = e.conversion), t; + })(A)); + }); + }), + (e.exports = o); + }, + 78577: (e, t, r) => { + const A = r(15311); + function n(e) { + const t = (function () { + const e = {}, + t = Object.keys(A); + for (let r = t.length, A = 0; A < r; A++) + e[t[A]] = { distance: -1, parent: null }; + return e; + })(), + r = [e]; + for (t[e].distance = 0; r.length; ) { + const e = r.pop(), + n = Object.keys(A[e]); + for (let A = n.length, o = 0; o < A; o++) { + const A = n[o], + i = t[A]; + -1 === i.distance && + ((i.distance = t[e].distance + 1), + (i.parent = e), + r.unshift(A)); + } + } + return t; + } + function o(e, t) { + return function (r) { + return t(e(r)); + }; + } + function i(e, t) { + const r = [t[e].parent, e]; + let n = A[t[e].parent][e], + i = t[e].parent; + for (; t[i].parent; ) + r.unshift(t[i].parent), + (n = o(A[t[i].parent][i], n)), + (i = t[i].parent); + return (n.conversion = r), n; + } + e.exports = function (e) { + const t = n(e), + r = {}, + A = Object.keys(t); + for (let e = A.length, n = 0; n < e; n++) { + const e = A[n]; + null !== t[e].parent && (r[e] = i(e, t)); + } + return r; + }; + }, + 93300: (e) => { + 'use strict'; + e.exports = { + aliceblue: [240, 248, 255], + antiquewhite: [250, 235, 215], + aqua: [0, 255, 255], + aquamarine: [127, 255, 212], + azure: [240, 255, 255], + beige: [245, 245, 220], + bisque: [255, 228, 196], + black: [0, 0, 0], + blanchedalmond: [255, 235, 205], + blue: [0, 0, 255], + blueviolet: [138, 43, 226], + brown: [165, 42, 42], + burlywood: [222, 184, 135], + cadetblue: [95, 158, 160], + chartreuse: [127, 255, 0], + chocolate: [210, 105, 30], + coral: [255, 127, 80], + cornflowerblue: [100, 149, 237], + cornsilk: [255, 248, 220], + crimson: [220, 20, 60], + cyan: [0, 255, 255], + darkblue: [0, 0, 139], + darkcyan: [0, 139, 139], + darkgoldenrod: [184, 134, 11], + darkgray: [169, 169, 169], + darkgreen: [0, 100, 0], + darkgrey: [169, 169, 169], + darkkhaki: [189, 183, 107], + darkmagenta: [139, 0, 139], + darkolivegreen: [85, 107, 47], + darkorange: [255, 140, 0], + darkorchid: [153, 50, 204], + darkred: [139, 0, 0], + darksalmon: [233, 150, 122], + darkseagreen: [143, 188, 143], + darkslateblue: [72, 61, 139], + darkslategray: [47, 79, 79], + darkslategrey: [47, 79, 79], + darkturquoise: [0, 206, 209], + darkviolet: [148, 0, 211], + deeppink: [255, 20, 147], + deepskyblue: [0, 191, 255], + dimgray: [105, 105, 105], + dimgrey: [105, 105, 105], + dodgerblue: [30, 144, 255], + firebrick: [178, 34, 34], + floralwhite: [255, 250, 240], + forestgreen: [34, 139, 34], + fuchsia: [255, 0, 255], + gainsboro: [220, 220, 220], + ghostwhite: [248, 248, 255], + gold: [255, 215, 0], + goldenrod: [218, 165, 32], + gray: [128, 128, 128], + green: [0, 128, 0], + greenyellow: [173, 255, 47], + grey: [128, 128, 128], + honeydew: [240, 255, 240], + hotpink: [255, 105, 180], + indianred: [205, 92, 92], + indigo: [75, 0, 130], + ivory: [255, 255, 240], + khaki: [240, 230, 140], + lavender: [230, 230, 250], + lavenderblush: [255, 240, 245], + lawngreen: [124, 252, 0], + lemonchiffon: [255, 250, 205], + lightblue: [173, 216, 230], + lightcoral: [240, 128, 128], + lightcyan: [224, 255, 255], + lightgoldenrodyellow: [250, 250, 210], + lightgray: [211, 211, 211], + lightgreen: [144, 238, 144], + lightgrey: [211, 211, 211], + lightpink: [255, 182, 193], + lightsalmon: [255, 160, 122], + lightseagreen: [32, 178, 170], + lightskyblue: [135, 206, 250], + lightslategray: [119, 136, 153], + lightslategrey: [119, 136, 153], + lightsteelblue: [176, 196, 222], + lightyellow: [255, 255, 224], + lime: [0, 255, 0], + limegreen: [50, 205, 50], + linen: [250, 240, 230], + magenta: [255, 0, 255], + maroon: [128, 0, 0], + mediumaquamarine: [102, 205, 170], + mediumblue: [0, 0, 205], + mediumorchid: [186, 85, 211], + mediumpurple: [147, 112, 219], + mediumseagreen: [60, 179, 113], + mediumslateblue: [123, 104, 238], + mediumspringgreen: [0, 250, 154], + mediumturquoise: [72, 209, 204], + mediumvioletred: [199, 21, 133], + midnightblue: [25, 25, 112], + mintcream: [245, 255, 250], + mistyrose: [255, 228, 225], + moccasin: [255, 228, 181], + navajowhite: [255, 222, 173], + navy: [0, 0, 128], + oldlace: [253, 245, 230], + olive: [128, 128, 0], + olivedrab: [107, 142, 35], + orange: [255, 165, 0], + orangered: [255, 69, 0], + orchid: [218, 112, 214], + palegoldenrod: [238, 232, 170], + palegreen: [152, 251, 152], + paleturquoise: [175, 238, 238], + palevioletred: [219, 112, 147], + papayawhip: [255, 239, 213], + peachpuff: [255, 218, 185], + peru: [205, 133, 63], + pink: [255, 192, 203], + plum: [221, 160, 221], + powderblue: [176, 224, 230], + purple: [128, 0, 128], + rebeccapurple: [102, 51, 153], + red: [255, 0, 0], + rosybrown: [188, 143, 143], + royalblue: [65, 105, 225], + saddlebrown: [139, 69, 19], + salmon: [250, 128, 114], + sandybrown: [244, 164, 96], + seagreen: [46, 139, 87], + seashell: [255, 245, 238], + sienna: [160, 82, 45], + silver: [192, 192, 192], + skyblue: [135, 206, 235], + slateblue: [106, 90, 205], + slategray: [112, 128, 144], + slategrey: [112, 128, 144], + snow: [255, 250, 250], + springgreen: [0, 255, 127], + steelblue: [70, 130, 180], + tan: [210, 180, 140], + teal: [0, 128, 128], + thistle: [216, 191, 216], + tomato: [255, 99, 71], + turquoise: [64, 224, 208], + violet: [238, 130, 238], + wheat: [245, 222, 179], + white: [255, 255, 255], + whitesmoke: [245, 245, 245], + yellow: [255, 255, 0], + yellowgreen: [154, 205, 50], + }; + }, + 67566: (e, t, r) => { + 'use strict'; + const A = r(63129), + n = r(14951), + o = r(10779); + function i(e, t, r) { + const i = n(e, t, r), + s = A.spawn(i.command, i.args, i.options); + return o.hookChildProcess(s, i), s; + } + (e.exports = i), + (e.exports.spawn = i), + (e.exports.sync = function (e, t, r) { + const i = n(e, t, r), + s = A.spawnSync(i.command, i.args, i.options); + return (s.error = s.error || o.verifyENOENTSync(s.status, i)), s; + }), + (e.exports._parse = n), + (e.exports._enoent = o); + }, + 10779: (e) => { + 'use strict'; + const t = 'win32' === process.platform; + function r(e, t) { + return Object.assign(new Error(`${t} ${e.command} ENOENT`), { + code: 'ENOENT', + errno: 'ENOENT', + syscall: `${t} ${e.command}`, + path: e.command, + spawnargs: e.args, + }); + } + function A(e, A) { + return t && 1 === e && !A.file ? r(A.original, 'spawn') : null; + } + e.exports = { + hookChildProcess: function (e, r) { + if (!t) return; + const n = e.emit; + e.emit = function (t, o) { + if ('exit' === t) { + const t = A(o, r); + if (t) return n.call(e, 'error', t); + } + return n.apply(e, arguments); + }; + }, + verifyENOENT: A, + verifyENOENTSync: function (e, A) { + return t && 1 === e && !A.file ? r(A.original, 'spawnSync') : null; + }, + notFoundError: r, + }; + }, + 14951: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = r(47447), + o = r(27066), + i = r(35187), + s = 'win32' === process.platform, + a = /\.(?:com|exe)$/i, + c = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i; + function g(e) { + if (!s) return e; + const t = (function (e) { + e.file = n(e); + const t = e.file && i(e.file); + return t + ? (e.args.unshift(e.file), (e.command = t), n(e)) + : e.file; + })(e), + r = !a.test(t); + if (e.options.forceShell || r) { + const r = c.test(t); + (e.command = A.normalize(e.command)), + (e.command = o.command(e.command)), + (e.args = e.args.map((e) => o.argument(e, r))); + const n = [e.command].concat(e.args).join(' '); + (e.args = ['/d', '/s', '/c', `"${n}"`]), + (e.command = process.env.comspec || 'cmd.exe'), + (e.options.windowsVerbatimArguments = !0); + } + return e; + } + e.exports = function (e, t, r) { + t && !Array.isArray(t) && ((r = t), (t = null)); + const A = { + command: e, + args: (t = t ? t.slice(0) : []), + options: (r = Object.assign({}, r)), + file: void 0, + original: { command: e, args: t }, + }; + return r.shell ? A : g(A); + }; + }, + 27066: (e) => { + 'use strict'; + const t = /([()\][%!^"`<>&|;, *?])/g; + (e.exports.command = function (e) { + return (e = e.replace(t, '^$1')); + }), + (e.exports.argument = function (e, r) { + return ( + (e = (e = `"${(e = (e = (e = '' + e).replace( + /(\\*)"/g, + '$1$1\\"' + )).replace(/(\\*)$/, '$1$1'))}"`).replace(t, '^$1')), + r && (e = e.replace(t, '^$1')), + e + ); + }); + }, + 35187: (e, t, r) => { + 'use strict'; + const A = r(35747), + n = r(91470); + e.exports = function (e) { + const t = Buffer.alloc(150); + let r; + try { + (r = A.openSync(e, 'r')), + A.readSync(r, t, 0, 150, 0), + A.closeSync(r); + } catch (e) {} + return n(t.toString()); + }; + }, + 47447: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = r(87945), + o = r(37127); + function i(e, t) { + const r = e.options.env || process.env, + i = process.cwd(), + s = null != e.options.cwd, + a = s && void 0 !== process.chdir && !process.chdir.disabled; + if (a) + try { + process.chdir(e.options.cwd); + } catch (e) {} + let c; + try { + c = n.sync(e.command, { + path: r[o({ env: r })], + pathExt: t ? A.delimiter : void 0, + }); + } catch (e) { + } finally { + a && process.chdir(i); + } + return c && (c = A.resolve(s ? e.options.cwd : '', c)), c; + } + e.exports = function (e) { + return i(e) || i(e, !0); + }; + }, + 93868: (e, t, r) => { + 'use strict'; + const { Transform: A, PassThrough: n } = r(92413), + o = r(78761), + i = r(33527); + e.exports = (e) => { + const t = (e.headers['content-encoding'] || '').toLowerCase(); + if (!['gzip', 'deflate', 'br'].includes(t)) return e; + const r = 'br' === t; + if (r && 'function' != typeof o.createBrotliDecompress) + return ( + e.destroy(new Error('Brotli is not supported on Node.js < 12')), e + ); + let s = !0; + const a = new A({ + transform(e, t, r) { + (s = !1), r(null, e); + }, + flush(e) { + e(); + }, + }), + c = new n({ + autoDestroy: !1, + destroy(t, r) { + e.destroy(), r(t); + }, + }), + g = r ? o.createBrotliDecompress() : o.createUnzip(); + return ( + g.once('error', (t) => { + !s || e.readable ? c.destroy(t) : c.end(); + }), + i(e, c), + e.pipe(a).pipe(g).pipe(c), + c + ); + }; + }, + 93121: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(4016), + n = (e, t) => { + let r; + if ('function' == typeof t) { + r = { connect: t }; + } else r = t; + const n = 'function' == typeof r.connect, + o = 'function' == typeof r.secureConnect, + i = 'function' == typeof r.close, + s = () => { + n && r.connect(), + e instanceof A.TLSSocket && + o && + (e.authorized + ? r.secureConnect() + : e.authorizationError || + e.once('secureConnect', r.secureConnect)), + i && e.once('close', r.close); + }; + e.writable && !e.connecting + ? s() + : e.connecting + ? e.once('connect', s) + : e.destroyed && i && r.close(e._hadError); + }; + (t.default = n), (e.exports = n), (e.exports.default = n); + }, + 66241: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = r(5763), + o = (e) => (e.length > 1 ? `{${e.join(',')}}` : e[0]), + i = (e, t) => { + const r = '!' === e[0] ? e.slice(1) : e; + return A.isAbsolute(r) ? r : A.join(t, r); + }, + s = (e, t) => { + if (t.files && !Array.isArray(t.files)) + throw new TypeError( + `Expected \`files\` to be of type \`Array\` but received type \`${typeof t.files}\`` + ); + if (t.extensions && !Array.isArray(t.extensions)) + throw new TypeError( + `Expected \`extensions\` to be of type \`Array\` but received type \`${typeof t.extensions}\`` + ); + return t.files && t.extensions + ? t.files.map((r) => { + return A.posix.join( + e, + ((n = r), + (i = t.extensions), + A.extname(n) ? '**/' + n : `**/${n}.${o(i)}`) + ); + var n, i; + }) + : t.files + ? t.files.map((t) => A.posix.join(e, '**/' + t)) + : t.extensions + ? [A.posix.join(e, '**/*.' + o(t.extensions))] + : [A.posix.join(e, '**')]; + }; + (e.exports = async (e, t) => { + if ('string' != typeof (t = { cwd: process.cwd(), ...t }).cwd) + throw new TypeError( + `Expected \`cwd\` to be of type \`string\` but received type \`${typeof t.cwd}\`` + ); + const r = await Promise.all( + [] + .concat(e) + .map(async (e) => + (await n.isDirectory(i(e, t.cwd))) ? s(e, t) : e + ) + ); + return [].concat.apply([], r); + }), + (e.exports.sync = (e, t) => { + if ('string' != typeof (t = { cwd: process.cwd(), ...t }).cwd) + throw new TypeError( + `Expected \`cwd\` to be of type \`string\` but received type \`${typeof t.cwd}\`` + ); + const r = [] + .concat(e) + .map((e) => (n.isDirectorySync(i(e, t.cwd)) ? s(e, t) : e)); + return [].concat.apply([], r); + }); + }, + 97681: (e, t, r) => { + var A = r(91162), + n = function () {}, + o = function (e, t, r) { + if ('function' == typeof t) return o(e, null, t); + t || (t = {}), (r = A(r || n)); + var i = e._writableState, + s = e._readableState, + a = t.readable || (!1 !== t.readable && e.readable), + c = t.writable || (!1 !== t.writable && e.writable), + g = function () { + e.writable || l(); + }, + l = function () { + (c = !1), a || r(); + }, + u = function () { + (a = !1), c || r(); + }, + h = function (e) { + r(e ? new Error('exited with error code: ' + e) : null); + }, + p = function () { + return (!a || (s && s.ended)) && (!c || (i && i.ended)) + ? void 0 + : r(new Error('premature close')); + }, + d = function () { + e.req.on('finish', l); + }; + return ( + !(function (e) { + return e.setHeader && 'function' == typeof e.abort; + })(e) + ? c && !i && (e.on('end', g), e.on('close', g)) + : (e.on('complete', l), + e.on('abort', p), + e.req ? d() : e.on('request', d)), + (function (e) { + return ( + e.stdio && Array.isArray(e.stdio) && 3 === e.stdio.length + ); + })(e) && e.on('exit', h), + e.on('end', u), + e.on('finish', l), + !1 !== t.error && e.on('error', r), + e.on('close', p), + function () { + e.removeListener('complete', l), + e.removeListener('abort', p), + e.removeListener('request', d), + e.req && e.req.removeListener('finish', l), + e.removeListener('end', g), + e.removeListener('close', g), + e.removeListener('finish', l), + e.removeListener('exit', h), + e.removeListener('end', u), + e.removeListener('error', r), + e.removeListener('close', p); + } + ); + }; + e.exports = o; + }, + 17067: (e, t, r) => { + var A = r(27180), + n = function () {}, + o = function (e, t, r) { + if ('function' == typeof t) return o(e, null, t); + t || (t = {}), (r = A(r || n)); + var i = e._writableState, + s = e._readableState, + a = t.readable || (!1 !== t.readable && e.readable), + c = t.writable || (!1 !== t.writable && e.writable), + g = function () { + e.writable || l(); + }, + l = function () { + (c = !1), a || r.call(e); + }, + u = function () { + (a = !1), c || r.call(e); + }, + h = function (t) { + r.call(e, t ? new Error('exited with error code: ' + t) : null); + }, + p = function (t) { + r.call(e, t); + }, + d = function () { + return (!a || (s && s.ended)) && (!c || (i && i.ended)) + ? void 0 + : r.call(e, new Error('premature close')); + }, + C = function () { + e.req.on('finish', l); + }; + return ( + !(function (e) { + return e.setHeader && 'function' == typeof e.abort; + })(e) + ? c && !i && (e.on('end', g), e.on('close', g)) + : (e.on('complete', l), + e.on('abort', d), + e.req ? C() : e.on('request', C)), + (function (e) { + return ( + e.stdio && Array.isArray(e.stdio) && 3 === e.stdio.length + ); + })(e) && e.on('exit', h), + e.on('end', u), + e.on('finish', l), + !1 !== t.error && e.on('error', p), + e.on('close', d), + function () { + e.removeListener('complete', l), + e.removeListener('abort', d), + e.removeListener('request', C), + e.req && e.req.removeListener('finish', l), + e.removeListener('end', g), + e.removeListener('close', g), + e.removeListener('finish', l), + e.removeListener('exit', h), + e.removeListener('end', u), + e.removeListener('error', p), + e.removeListener('close', d); + } + ); + }; + e.exports = o; + }, + 61899: (e, t, r) => { + 'use strict'; + const A = r(42357), + n = r(28614), + o = r(10278); + class i extends n { + constructor(e, t) { + super(), (this.options = o.merge({}, e)), (this.answers = { ...t }); + } + register(e, t) { + if (o.isObject(e)) { + for (let t of Object.keys(e)) this.register(t, e[t]); + return this; + } + A.equal(typeof t, 'function', 'expected a function'); + let r = e.toLowerCase(); + return ( + t.prototype instanceof this.Prompt + ? (this.prompts[r] = t) + : (this.prompts[r] = t(this.Prompt, this)), + this + ); + } + async prompt(e = []) { + for (let t of [].concat(e)) + try { + 'function' == typeof t && (t = await t.call(this)), + await this.ask(o.merge({}, this.options, t)); + } catch (e) { + return Promise.reject(e); + } + return this.answers; + } + async ask(e) { + 'function' == typeof e && (e = await e.call(this)); + let t = o.merge({}, this.options, e), + { type: r, name: n } = e, + { set: i, get: s } = o; + if ( + ('function' == typeof r && + (r = await r.call(this, e, this.answers)), + !r) + ) + return this.answers[n]; + A(this.prompts[r], `Prompt "${r}" is not registered`); + let a = new this.prompts[r](t), + c = s(this.answers, n); + (a.state.answers = this.answers), + (a.enquirer = this), + n && + a.on('submit', (e) => { + this.emit('answer', n, e, a), i(this.answers, n, e); + }); + let g = a.emit.bind(a); + return ( + (a.emit = (...e) => (this.emit.call(this, ...e), g(...e))), + this.emit('prompt', a, this), + t.autofill && null != c + ? ((a.value = a.input = c), + 'show' === t.autofill && (await a.submit())) + : (c = a.value = await a.run()), + c + ); + } + use(e) { + return e.call(this, this), this; + } + set Prompt(e) { + this._Prompt = e; + } + get Prompt() { + return this._Prompt || this.constructor.Prompt; + } + get prompts() { + return this.constructor.prompts; + } + static set Prompt(e) { + this._Prompt = e; + } + static get Prompt() { + return this._Prompt || r(58386); + } + static get prompts() { + return r(53609); + } + static get types() { + return r(13235); + } + static get prompt() { + const e = (t, ...r) => { + let A = new this(...r), + n = A.emit.bind(A); + return (A.emit = (...t) => (e.emit(...t), n(...t))), A.prompt(t); + }; + return o.mixinEmitter(e, new n()), e; + } + } + o.mixinEmitter(i, new n()); + const s = i.prompts; + for (let e of Object.keys(s)) { + let t = e.toLowerCase(), + r = (t) => new s[e](t).run(); + (i.prompt[t] = r), + (i[t] = r), + i[e] || Reflect.defineProperty(i, e, { get: () => s[e] }); + } + const a = (e) => { + o.defineExport(i, e, () => i.types[e]); + }; + a('ArrayPrompt'), + a('AuthPrompt'), + a('BooleanPrompt'), + a('NumberPrompt'), + a('StringPrompt'), + (e.exports = i); + }, + 72380: (e, t, r) => { + 'use strict'; + const A = 'Apple_Terminal' === process.env.TERM_PROGRAM, + n = r(97991), + o = r(10278), + i = (e.exports = t), + s = '['; + let a = !1; + const c = (i.code = { + bell: '', + beep: '', + beginning: '', + down: '', + esc: s, + getPosition: '', + hide: '[?25l', + line: '', + lineEnd: '', + lineStart: '', + restorePosition: s + (A ? '8' : 'u'), + savePosition: s + (A ? '7' : 's'), + screen: '', + show: '[?25h', + up: '', + }), + g = (i.cursor = { + get hidden() { + return a; + }, + hide: () => ((a = !0), c.hide), + show: () => ((a = !1), c.show), + forward: (e = 1) => `[${e}C`, + backward: (e = 1) => `[${e}D`, + nextLine: (e = 1) => ''.repeat(e), + prevLine: (e = 1) => ''.repeat(e), + up: (e = 1) => (e ? `[${e}A` : ''), + down: (e = 1) => (e ? `[${e}B` : ''), + right: (e = 1) => (e ? `[${e}C` : ''), + left: (e = 1) => (e ? `[${e}D` : ''), + to: (e, t) => (t ? `[${t + 1};${e + 1}H` : `[${e + 1}G`), + move(e = 0, t = 0) { + let r = ''; + return ( + (r += e < 0 ? g.left(-e) : e > 0 ? g.right(e) : ''), + (r += t < 0 ? g.up(-t) : t > 0 ? g.down(t) : ''), + r + ); + }, + restore(e = {}) { + let { + after: t, + cursor: r, + initial: A, + input: n, + prompt: s, + size: a, + value: c, + } = e; + if ( + ((A = o.isPrimitive(A) ? String(A) : ''), + (n = o.isPrimitive(n) ? String(n) : ''), + (c = o.isPrimitive(c) ? String(c) : ''), + a) + ) { + let e = i.cursor.up(a) + i.cursor.to(s.length), + t = n.length - r; + return t > 0 && (e += i.cursor.left(t)), e; + } + if (c || t) { + let e = !n && A ? -A.length : -n.length + r; + return ( + t && (e -= t.length), + '' === n && A && !s.includes(A) && (e += A.length), + i.cursor.move(e) + ); + } + }, + }), + l = (i.erase = { + screen: c.screen, + up: c.up, + down: c.down, + line: c.line, + lineEnd: c.lineEnd, + lineStart: c.lineStart, + lines(e) { + let t = ''; + for (let r = 0; r < e; r++) + t += i.erase.line + (r < e - 1 ? i.cursor.up(1) : ''); + return e && (t += i.code.beginning), t; + }, + }); + i.clear = (e = '', t = process.stdout.columns) => { + if (!t) return l.line + g.to(0); + let r = e.split(/\r?\n/), + A = 0; + for (let e of r) + A += + 1 + + Math.floor( + Math.max(((o = e), [...n.unstyle(o)].length - 1), 0) / t + ); + var o; + return (l.line + g.prevLine()).repeat(A - 1) + l.line + g.to(0); + }; + }, + 62475: (e, t) => { + 'use strict'; + (t.ctrl = { + a: 'first', + b: 'backward', + c: 'cancel', + d: 'deleteForward', + e: 'last', + f: 'forward', + g: 'reset', + i: 'tab', + k: 'cutForward', + l: 'reset', + n: 'newItem', + m: 'cancel', + j: 'submit', + p: 'search', + r: 'remove', + s: 'save', + u: 'undo', + w: 'cutLeft', + x: 'toggleCursor', + v: 'paste', + }), + (t.shift = { + up: 'shiftUp', + down: 'shiftDown', + left: 'shiftLeft', + right: 'shiftRight', + tab: 'prev', + }), + (t.fn = { + up: 'pageUp', + down: 'pageDown', + left: 'pageLeft', + right: 'pageRight', + delete: 'deleteForward', + }), + (t.option = { + b: 'backward', + f: 'forward', + d: 'cutRight', + left: 'cutLeft', + up: 'altUp', + down: 'altDown', + }), + (t.keys = { + pageup: 'pageUp', + pagedown: 'pageDown', + home: 'home', + end: 'end', + cancel: 'cancel', + delete: 'deleteForward', + backspace: 'delete', + down: 'down', + enter: 'submit', + escape: 'cancel', + left: 'left', + space: 'space', + number: 'number', + return: 'submit', + right: 'right', + tab: 'next', + up: 'up', + }); + }, + 64083: (e) => { + 'use strict'; + const t = (e) => + ((e) => e.filter((t, r) => e.lastIndexOf(t) === r))(e).filter( + Boolean + ); + e.exports = (e, r = {}, A = '') => { + let n, + o, + { past: i = [], present: s = '' } = r; + switch (e) { + case 'prev': + case 'undo': + return ( + (n = i.slice(0, i.length - 1)), + (o = i[i.length - 1] || ''), + { past: t([A, ...n]), present: o } + ); + case 'next': + case 'redo': + return ( + (n = i.slice(1)), + (o = i[0] || ''), + { past: t([...n, A]), present: o } + ); + case 'save': + return { past: t([...i, A]), present: '' }; + case 'remove': + return ( + (o = t(i.filter((e) => e !== A))), + (s = ''), + o.length && (s = o.pop()), + { past: o, present: s } + ); + default: + throw new Error(`Invalid action: "${e}"`); + } + }; + }, + 84368: (e, t, r) => { + 'use strict'; + const A = r(97991); + class n { + constructor(e) { + (this.name = e.key), + (this.field = e.field || {}), + (this.value = ((e = '') => + 'string' == typeof e ? e.replace(/^['"]|['"]$/g, '') : '')( + e.initial || this.field.initial || '' + )), + (this.message = e.message || this.name), + (this.cursor = 0), + (this.input = ''), + (this.lines = []); + } + } + function o(e, t, r, A) { + return (r, n, o, i) => + 'function' == typeof o.field[e] + ? o.field[e].call(t, r, n, o, i) + : [A, r].find((e) => t.isValue(e)); + } + e.exports = async (e) => { + let t = e.options, + r = new Set(!0 === t.required ? [] : t.required || []), + i = { ...t.values, ...t.initial }, + { tabstops: s, items: a, keys: c } = await (async ( + e = {}, + t = {}, + r = (e) => e + ) => { + let A = new Set(), + o = e.fields || [], + i = e.template, + s = [], + a = [], + c = [], + g = 1; + 'function' == typeof i && (i = await i()); + let l = -1, + u = () => i[++l], + h = () => i[l + 1], + p = (e) => { + (e.line = g), s.push(e); + }; + for (p({ type: 'bos', value: '' }); l < i.length - 1; ) { + let e = u(); + if (/^[^\S\n ]$/.test(e)) { + p({ type: 'text', value: e }); + continue; + } + if ('\n' === e) { + p({ type: 'newline', value: e }), g++; + continue; + } + if ('\\' === e) { + (e += u()), p({ type: 'text', value: e }); + continue; + } + if (('$' === e || '#' === e || '{' === e) && '{' === h()) { + e += u(); + let i, + s = { + type: 'template', + open: e, + inner: '', + close: '', + value: e, + }; + for (; (i = u()); ) { + if ('}' === i) { + '}' === h() && (i += u()), (s.value += i), (s.close = i); + break; + } + ':' === i + ? ((s.initial = ''), (s.key = s.inner)) + : void 0 !== s.initial && (s.initial += i), + (s.value += i), + (s.inner += i); + } + (s.template = s.open + (s.initial || s.inner) + s.close), + (s.key = s.key || s.inner), + t.hasOwnProperty(s.key) && (s.initial = t[s.key]), + (s = r(s)), + p(s), + c.push(s.key), + A.add(s.key); + let g = a.find((e) => e.name === s.key); + (s.field = o.find((e) => e.name === s.key)), + g || ((g = new n(s)), a.push(g)), + g.lines.push(s.line - 1); + continue; + } + let i = s[s.length - 1]; + 'text' === i.type && i.line === g + ? (i.value += e) + : p({ type: 'text', value: e }); + } + return ( + p({ type: 'eos', value: '' }), + { input: i, tabstops: s, unique: A, keys: c, items: a } + ); + })(t, i), + g = o('result', e, t), + l = o('format', e, t), + u = o('validate', e, t, !0), + h = e.isValue.bind(e); + return async (n = {}, o = !1) => { + let i = 0; + (n.required = r), (n.items = a), (n.keys = c), (n.output = ''); + let p = async (e, t, r, A) => { + let n = await u(e, t, r, A); + return !1 === n ? 'Invalid field ' + r.name : n; + }; + for (let r of s) { + let s = r.value, + c = r.key; + if ('template' === r.type) { + if ('template' === r.type) { + let u = a.find((e) => e.name === c); + !0 === t.required && n.required.add(u.name); + let d = [u.input, n.values[u.value], u.value, s].find(h), + C = (u.field || {}).message || r.inner; + if (o) { + let e = await p(n.values[c], n, u, i); + if ((e && 'string' == typeof e) || !1 === e) { + n.invalid.set(c, e); + continue; + } + n.invalid.delete(c); + let t = await g(n.values[c], n, u, i); + n.output += A.unstyle(t); + continue; + } + u.placeholder = !1; + let f = s; + (s = await l(s, n, u, i)), + d !== s + ? ((n.values[c] = d), + (s = e.styles.typing(d)), + n.missing.delete(C)) + : ((n.values[c] = void 0), + (d = `<${C}>`), + (s = e.styles.primary(d)), + (u.placeholder = !0), + n.required.has(c) && n.missing.add(C)), + n.missing.has(C) && + n.validating && + (s = e.styles.warning(d)), + n.invalid.has(c) && + n.validating && + (s = e.styles.danger(d)), + i === n.index && + (s = + f !== s + ? e.styles.underline(s) + : e.styles.heading(A.unstyle(s))), + i++; + } + s && (n.output += s); + } else s && (n.output += s); + } + let d = n.output.split('\n').map((e) => ' ' + e), + C = a.length, + f = 0; + for (let t of a) + n.invalid.has(t.name) && + t.lines.forEach((e) => { + ' ' === d[e][0] && + (d[e] = n.styles.danger(n.symbols.bullet) + d[e].slice(1)); + }), + e.isValue(n.values[t.name]) && f++; + return ( + (n.completed = ((f / C) * 100).toFixed(0)), + (n.output = d.join('\n')), + n.output + ); + }; + }; + }, + 30650: (e, t, r) => { + 'use strict'; + const A = r(51058), + n = r(62475), + o = /^(?:\x1b)([a-zA-Z0-9])$/, + i = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/, + s = { + OP: 'f1', + OQ: 'f2', + OR: 'f3', + OS: 'f4', + '[11~': 'f1', + '[12~': 'f2', + '[13~': 'f3', + '[14~': 'f4', + '[[A': 'f1', + '[[B': 'f2', + '[[C': 'f3', + '[[D': 'f4', + '[[E': 'f5', + '[15~': 'f5', + '[17~': 'f6', + '[18~': 'f7', + '[19~': 'f8', + '[20~': 'f9', + '[21~': 'f10', + '[23~': 'f11', + '[24~': 'f12', + '[A': 'up', + '[B': 'down', + '[C': 'right', + '[D': 'left', + '[E': 'clear', + '[F': 'end', + '[H': 'home', + OA: 'up', + OB: 'down', + OC: 'right', + OD: 'left', + OE: 'clear', + OF: 'end', + OH: 'home', + '[1~': 'home', + '[2~': 'insert', + '[3~': 'delete', + '[4~': 'end', + '[5~': 'pageup', + '[6~': 'pagedown', + '[[5~': 'pageup', + '[[6~': 'pagedown', + '[7~': 'home', + '[8~': 'end', + '[a': 'up', + '[b': 'down', + '[c': 'right', + '[d': 'left', + '[e': 'clear', + '[2$': 'insert', + '[3$': 'delete', + '[5$': 'pageup', + '[6$': 'pagedown', + '[7$': 'home', + '[8$': 'end', + Oa: 'up', + Ob: 'down', + Oc: 'right', + Od: 'left', + Oe: 'clear', + '[2^': 'insert', + '[3^': 'delete', + '[5^': 'pageup', + '[6^': 'pagedown', + '[7^': 'home', + '[8^': 'end', + '[Z': 'tab', + }; + const a = (e = '', t = {}) => { + let r, + A = { + name: t.name, + ctrl: !1, + meta: !1, + shift: !1, + option: !1, + sequence: e, + raw: e, + ...t, + }; + if ( + (Buffer.isBuffer(e) + ? e[0] > 127 && void 0 === e[1] + ? ((e[0] -= 128), (e = '' + String(e))) + : (e = String(e)) + : void 0 !== e && 'string' != typeof e + ? (e = String(e)) + : e || (e = A.sequence || ''), + (A.sequence = A.sequence || e || A.name), + '\r' === e) + ) + (A.raw = void 0), (A.name = 'return'); + else if ('\n' === e) A.name = 'enter'; + else if ('\t' === e) A.name = 'tab'; + else if ('\b' === e || '' === e || '' === e || '\b' === e) + (A.name = 'backspace'), (A.meta = '' === e.charAt(0)); + else if ('' === e || '' === e) + (A.name = 'escape'), (A.meta = 2 === e.length); + else if (' ' === e || ' ' === e) + (A.name = 'space'), (A.meta = 2 === e.length); + else if (e <= '') + (A.name = String.fromCharCode( + e.charCodeAt(0) + 'a'.charCodeAt(0) - 1 + )), + (A.ctrl = !0); + else if (1 === e.length && e >= '0' && e <= '9') A.name = 'number'; + else if (1 === e.length && e >= 'a' && e <= 'z') A.name = e; + else if (1 === e.length && e >= 'A' && e <= 'Z') + (A.name = e.toLowerCase()), (A.shift = !0); + else if ((r = o.exec(e))) + (A.meta = !0), (A.shift = /^[A-Z]$/.test(r[1])); + else if ((r = i.exec(e))) { + let t = [...e]; + '' === t[0] && '' === t[1] && (A.option = !0); + let n = [r[1], r[2], r[4], r[6]].filter(Boolean).join(''), + o = (r[3] || r[5] || 1) - 1; + (A.ctrl = !!(4 & o)), + (A.meta = !!(10 & o)), + (A.shift = !!(1 & o)), + (A.code = n), + (A.name = s[n]), + (A.shift = + (function (e) { + return [ + '[a', + '[b', + '[c', + '[d', + '[e', + '[2$', + '[3$', + '[5$', + '[6$', + '[7$', + '[8$', + '[Z', + ].includes(e); + })(n) || A.shift), + (A.ctrl = + (function (e) { + return [ + 'Oa', + 'Ob', + 'Oc', + 'Od', + 'Oe', + '[2^', + '[3^', + '[5^', + '[6^', + '[7^', + '[8^', + ].includes(e); + })(n) || A.ctrl); + } + return A; + }; + (a.listen = (e = {}, t) => { + let { stdin: r } = e; + if (!r || (r !== process.stdin && !r.isTTY)) + throw new Error('Invalid stream passed'); + let n = A.createInterface({ terminal: !0, input: r }); + A.emitKeypressEvents(r, n); + let o = (e, r) => t(e, a(e, r), n), + i = r.isRaw; + r.isTTY && r.setRawMode(!0), r.on('keypress', o), n.resume(); + return () => { + r.isTTY && r.setRawMode(i), + r.removeListener('keypress', o), + n.pause(), + n.close(); + }; + }), + (a.action = (e, t, r) => { + let A = { ...n, ...r }; + return t.ctrl + ? ((t.action = A.ctrl[t.name]), t) + : t.option && A.option + ? ((t.action = A.option[t.name]), t) + : t.shift + ? ((t.action = A.shift[t.name]), t) + : ((t.action = A.keys[t.name]), t); + }), + (e.exports = a); + }, + 96496: (e, t, r) => { + 'use strict'; + const A = r(10278); + e.exports = (e, t = {}) => { + e.cursorHide(); + let { + input: r = '', + initial: n = '', + pos: o, + showCursor: i = !0, + color: s, + } = t, + a = s || e.styles.placeholder, + c = A.inverse(e.styles.primary), + g = (t) => c(e.styles.black(t)), + l = r, + u = g(' '); + if ( + (e.blink && !0 === e.blink.off && ((g = (e) => e), (u = '')), + i && 0 === o && '' === n && '' === r) + ) + return g(' '); + if (i && 0 === o && (r === n || '' === r)) + return g(n[0]) + a(n.slice(1)); + (n = A.isPrimitive(n) ? '' + n : ''), + (r = A.isPrimitive(r) ? '' + r : ''); + let h = n && n.startsWith(r) && n !== r, + p = h ? g(n[r.length]) : u; + if ( + (o !== r.length && + !0 === i && + ((l = r.slice(0, o) + g(r[o]) + r.slice(o + 1)), (p = '')), + !1 === i && (p = ''), + h) + ) { + let t = e.styles.unstyle(l + p); + return l + p + a(n.slice(t.length)); + } + return l + p; + }; + }, + 58386: (e, t, r) => { + 'use strict'; + const A = r(28614), + n = r(97991), + o = r(30650), + i = r(47159), + s = r(61807), + a = r(26205), + c = r(10278), + g = r(72380); + class l extends A { + constructor(e = {}) { + super(), + (this.name = e.name), + (this.type = e.type), + (this.options = e), + a(this), + i(this), + (this.state = new s(this)), + (this.initial = [e.initial, e.default].find((e) => null != e)), + (this.stdout = e.stdout || process.stdout), + (this.stdin = e.stdin || process.stdin), + (this.scale = e.scale || 1), + (this.term = this.options.term || process.env.TERM_PROGRAM), + (this.margin = (function (e) { + 'number' == typeof e && (e = [e, e, e, e]); + let t = [].concat(e || []), + r = (e) => (e % 2 == 0 ? '\n' : ' '), + A = []; + for (let e = 0; e < 4; e++) { + let n = r(e); + t[e] ? A.push(n.repeat(t[e])) : A.push(''); + } + return A; + })(this.options.margin)), + this.setMaxListeners(0), + (function (e) { + let t = (t) => void 0 === e[t] || 'function' == typeof e[t], + r = [ + 'actions', + 'choices', + 'initial', + 'margin', + 'roles', + 'styles', + 'symbols', + 'theme', + 'timers', + 'value', + ], + A = [ + 'body', + 'footer', + 'error', + 'header', + 'hint', + 'indicator', + 'message', + 'prefix', + 'separator', + 'skip', + ]; + for (let n of Object.keys(e.options)) { + if (r.includes(n)) continue; + if (/^on[A-Z]/.test(n)) continue; + let o = e.options[n]; + 'function' == typeof o && t(n) + ? A.includes(n) || (e[n] = o.bind(e)) + : 'function' != typeof e[n] && (e[n] = o); + } + })(this); + } + async keypress(e, t = {}) { + this.keypressed = !0; + let r = o.action(e, o(e, t), this.options.actions); + (this.state.keypress = r), + this.emit('keypress', e, r), + this.emit('state', this.state.clone()); + let A = this.options[r.action] || this[r.action] || this.dispatch; + if ('function' == typeof A) return await A.call(this, e, r); + this.alert(); + } + alert() { + delete this.state.alert, + !1 === this.options.show + ? this.emit('alert') + : this.stdout.write(g.code.beep); + } + cursorHide() { + this.stdout.write(g.cursor.hide()), + c.onExit(() => this.cursorShow()); + } + cursorShow() { + this.stdout.write(g.cursor.show()); + } + write(e) { + e && + (this.stdout && !1 !== this.state.show && this.stdout.write(e), + (this.state.buffer += e)); + } + clear(e = 0) { + let t = this.state.buffer; + (this.state.buffer = ''), + (t || e) && + !1 !== this.options.show && + this.stdout.write(g.cursor.down(e) + g.clear(t, this.width)); + } + restore() { + if (this.state.closed || !1 === this.options.show) return; + let { prompt: e, after: t, rest: r } = this.sections(), + { + cursor: A, + initial: n = '', + input: o = '', + value: i = '', + } = this, + s = { + after: t, + cursor: A, + initial: n, + input: o, + prompt: e, + size: (this.state.size = r.length), + value: i, + }, + a = g.cursor.restore(s); + a && this.stdout.write(a); + } + sections() { + let { buffer: e, input: t, prompt: r } = this.state; + r = n.unstyle(r); + let A = n.unstyle(e), + o = A.indexOf(r), + i = A.slice(0, o), + s = A.slice(o).split('\n'), + a = s[0], + c = s[s.length - 1], + g = (r + (t ? ' ' + t : '')).length, + l = g < a.length ? a.slice(g + 1) : ''; + return { + header: i, + prompt: a, + after: l, + rest: s.slice(1), + last: c, + }; + } + async submit() { + (this.state.submitted = !0), + (this.state.validating = !0), + this.options.onSubmit && + (await this.options.onSubmit.call( + this, + this.name, + this.value, + this + )); + let e = + this.state.error || (await this.validate(this.value, this.state)); + if (!0 !== e) { + let t = '\n' + this.symbols.pointer + ' '; + return ( + (t += 'string' == typeof e ? e.trim() : 'Invalid input'), + (this.state.error = '\n' + this.styles.danger(t)), + (this.state.submitted = !1), + await this.render(), + await this.alert(), + (this.state.validating = !1), + void (this.state.error = void 0) + ); + } + (this.state.validating = !1), + await this.render(), + await this.close(), + (this.value = await this.result(this.value)), + this.emit('submit', this.value); + } + async cancel(e) { + (this.state.cancelled = this.state.submitted = !0), + await this.render(), + await this.close(), + 'function' == typeof this.options.onCancel && + (await this.options.onCancel.call( + this, + this.name, + this.value, + this + )), + this.emit('cancel', await this.error(e)); + } + async close() { + this.state.closed = !0; + try { + let e = this.sections(), + t = Math.ceil(e.prompt.length / this.width); + e.rest && this.write(g.cursor.down(e.rest.length)), + this.write('\n'.repeat(t)); + } catch (e) {} + this.emit('close'); + } + start() { + this.stop || + !1 === this.options.show || + ((this.stop = o.listen(this, this.keypress.bind(this))), + this.once('close', this.stop)); + } + async skip() { + return ( + (this.skipped = !0 === this.options.skip), + 'function' == typeof this.options.skip && + (this.skipped = await this.options.skip.call( + this, + this.name, + this.value + )), + this.skipped + ); + } + async initialize() { + let { format: e, options: t, result: r } = this; + if ( + ((this.format = () => e.call(this, this.value)), + (this.result = () => r.call(this, this.value)), + 'function' == typeof t.initial && + (this.initial = await t.initial.call(this, this)), + 'function' == typeof t.onRun && (await t.onRun.call(this, this)), + 'function' == typeof t.onSubmit) + ) { + let e = t.onSubmit.bind(this), + r = this.submit.bind(this); + delete this.options.onSubmit, + (this.submit = async () => ( + await e(this.name, this.value, this), r() + )); + } + await this.start(), await this.render(); + } + render() { + throw new Error('expected prompt to have a custom render method'); + } + run() { + return new Promise(async (e, t) => { + if ( + (this.once('submit', e), + this.once('cancel', t), + await this.skip()) + ) + return (this.render = () => {}), this.submit(); + await this.initialize(), this.emit('run'); + }); + } + async element(e, t, r) { + let { options: A, state: n, symbols: o, timers: i } = this, + s = i && i[e]; + n.timer = s; + let a = A[e] || n[e] || o[e], + c = t && null != t[e] ? t[e] : await a; + if ('' === c) return c; + let g = await this.resolve(c, n, t, r); + return !g && t && t[e] ? this.resolve(a, n, t, r) : g; + } + async prefix() { + let e = (await this.element('prefix')) || this.symbols, + t = this.timers && this.timers.prefix, + r = this.state; + if ( + ((r.timer = t), + c.isObject(e) && (e = e[r.status] || e.pending), + !c.hasColor(e)) + ) { + return (this.styles[r.status] || this.styles.pending)(e); + } + return e; + } + async message() { + let e = await this.element('message'); + return c.hasColor(e) ? e : this.styles.strong(e); + } + async separator() { + let e = (await this.element('separator')) || this.symbols, + t = this.timers && this.timers.separator, + r = this.state; + r.timer = t; + let A = e[r.status] || e.pending || r.separator, + n = await this.resolve(A, r); + return ( + c.isObject(n) && (n = n[r.status] || n.pending), + c.hasColor(n) ? n : this.styles.muted(n) + ); + } + async pointer(e, t) { + let r = await this.element('pointer', e, t); + if ('string' == typeof r && c.hasColor(r)) return r; + if (r) { + let e = this.styles, + A = this.index === t, + n = A ? e.primary : (e) => e, + o = await this.resolve(r[A ? 'on' : 'off'] || r, this.state), + i = c.hasColor(o) ? o : n(o); + return A ? i : ' '.repeat(o.length); + } + } + async indicator(e, t) { + let r = await this.element('indicator', e, t); + if ('string' == typeof r && c.hasColor(r)) return r; + if (r) { + let t = this.styles, + A = !0 === e.enabled, + n = A ? t.success : t.dark, + o = r[A ? 'on' : 'off'] || r; + return c.hasColor(o) ? o : n(o); + } + return ''; + } + body() { + return null; + } + footer() { + if ('pending' === this.state.status) return this.element('footer'); + } + header() { + if ('pending' === this.state.status) return this.element('header'); + } + async hint() { + if ( + 'pending' === this.state.status && + !this.isValue(this.state.input) + ) { + let e = await this.element('hint'); + return c.hasColor(e) ? e : this.styles.muted(e); + } + } + error(e) { + return this.state.submitted ? '' : e || this.state.error; + } + format(e) { + return e; + } + result(e) { + return e; + } + validate(e) { + return !0 !== this.options.required || this.isValue(e); + } + isValue(e) { + return null != e && '' !== e; + } + resolve(e, ...t) { + return c.resolve(this, e, ...t); + } + get base() { + return l.prototype; + } + get style() { + return this.styles[this.state.status]; + } + get height() { + return this.options.rows || c.height(this.stdout, 25); + } + get width() { + return this.options.columns || c.width(this.stdout, 80); + } + get size() { + return { width: this.width, height: this.height }; + } + set cursor(e) { + this.state.cursor = e; + } + get cursor() { + return this.state.cursor; + } + set input(e) { + this.state.input = e; + } + get input() { + return this.state.input; + } + set value(e) { + this.state.value = e; + } + get value() { + let { input: e, value: t } = this.state, + r = [t, e].find(this.isValue.bind(this)); + return this.isValue(r) ? r : this.initial; + } + static get prompt() { + return (e) => new this(e).run(); + } + } + e.exports = l; + }, + 63310: (e, t, r) => { + 'use strict'; + const A = r(31557); + e.exports = class extends A { + constructor(e) { + super(e), this.cursorShow(); + } + moveCursor(e) { + this.state.cursor += e; + } + dispatch(e) { + return this.append(e); + } + space(e) { + return this.options.multiple ? super.space(e) : this.append(e); + } + append(e) { + let { cursor: t, input: r } = this.state; + return ( + (this.input = r.slice(0, t) + e + r.slice(t)), + this.moveCursor(1), + this.complete() + ); + } + delete() { + let { cursor: e, input: t } = this.state; + return t + ? ((this.input = t.slice(0, e - 1) + t.slice(e)), + this.moveCursor(-1), + this.complete()) + : this.alert(); + } + deleteForward() { + let { cursor: e, input: t } = this.state; + return void 0 === t[e] + ? this.alert() + : ((this.input = ('' + t).slice(0, e) + ('' + t).slice(e + 1)), + this.complete()); + } + number(e) { + return this.append(e); + } + async complete() { + (this.completing = !0), + (this.choices = await this.suggest( + this.input, + this.state._choices + )), + (this.state.limit = void 0), + (this.index = Math.min( + Math.max(this.visible.length - 1, 0), + this.index + )), + await this.render(), + (this.completing = !1); + } + suggest(e = this.input, t = this.state._choices) { + if ('function' == typeof this.options.suggest) + return this.options.suggest.call(this, e, t); + let r = e.toLowerCase(); + return t.filter((e) => e.message.toLowerCase().includes(r)); + } + pointer() { + return ''; + } + format() { + if (!this.focused) return this.input; + if (this.options.multiple && this.state.submitted) + return this.selected + .map((e) => this.styles.primary(e.message)) + .join(', '); + if (this.state.submitted) { + let e = (this.value = this.input = this.focused.value); + return this.styles.primary(e); + } + return this.input; + } + async render() { + if ('pending' !== this.state.status) return super.render(); + let e = this.options.highlight + ? this.options.highlight.bind(this) + : this.styles.placeholder, + t = ((e, t) => { + let r = e.toLowerCase(); + return (e) => { + let A = e.toLowerCase().indexOf(r), + n = t(e.slice(A, A + r.length)); + return A >= 0 ? e.slice(0, A) + n + e.slice(A + r.length) : e; + }; + })(this.input, e), + r = this.choices; + (this.choices = r.map((e) => ({ ...e, message: t(e.message) }))), + await super.render(), + (this.choices = r); + } + submit() { + return ( + this.options.multiple && + (this.value = this.selected.map((e) => e.name)), + super.submit() + ); + } + }; + }, + 52810: (e, t, r) => { + 'use strict'; + const A = r(46614); + function n(e, t) { + return ( + e.username === this.options.username && + e.password === this.options.password + ); + } + const o = (e = n) => { + const t = [ + { name: 'username', message: 'username' }, + { + name: 'password', + message: 'password', + format(e) { + if (this.options.showPassword) return e; + return (this.state.submitted + ? this.styles.primary + : this.styles.muted)(this.symbols.asterisk.repeat(e.length)); + }, + }, + ]; + class r extends A.create(e) { + constructor(e) { + super({ ...e, choices: t }); + } + static create(e) { + return o(e); + } + } + return r; + }; + e.exports = o(); + }, + 65742: (e, t, r) => { + 'use strict'; + const A = r(82710); + e.exports = class extends A { + constructor(e) { + super(e), + (this.default = + this.options.default || (this.initial ? '(Y/n)' : '(y/N)')); + } + }; + }, + 24570: (e, t, r) => { + 'use strict'; + const A = r(31557), + n = r(71447).prototype; + e.exports = class extends A { + constructor(e) { + super({ ...e, multiple: !0 }), + (this.align = [this.options.align, 'left'].find( + (e) => null != e + )), + (this.emptyError = ''), + (this.values = {}); + } + dispatch(e, t) { + let r = this.focused, + A = r.parent || {}; + return r.editable || A.editable || ('a' !== e && 'i' !== e) + ? n.dispatch.call(this, e, t) + : super[e](); + } + append(e, t) { + return n.append.call(this, e, t); + } + delete(e, t) { + return n.delete.call(this, e, t); + } + space(e) { + return this.focused.editable ? this.append(e) : super.space(); + } + number(e) { + return this.focused.editable ? this.append(e) : super.number(e); + } + next() { + return this.focused.editable ? n.next.call(this) : super.next(); + } + prev() { + return this.focused.editable ? n.prev.call(this) : super.prev(); + } + async indicator(e, t) { + let r = e.indicator || '', + A = e.editable ? r : super.indicator(e, t); + return (await this.resolve(A, this.state, e, t)) || ''; + } + indent(e) { + return 'heading' === e.role ? '' : e.editable ? ' ' : ' '; + } + async renderChoice(e, t) { + return ( + (e.indent = ''), + e.editable + ? n.renderChoice.call(this, e, t) + : super.renderChoice(e, t) + ); + } + error() { + return ''; + } + footer() { + return this.state.error; + } + async validate() { + let e = !0; + for (let t of this.choices) { + if ('function' != typeof t.validate) continue; + if ('heading' === t.role) continue; + let r = t.parent ? this.value[t.parent.name] : this.value; + if ( + (t.editable + ? (r = t.value === t.name ? t.initial || '' : t.value) + : this.isDisabled(t) || (r = !0 === t.enabled), + (e = await t.validate(r, this.state)), + !0 !== e) + ) + break; + } + return ( + !0 !== e && + (this.state.error = 'string' == typeof e ? e : 'Invalid Input'), + e + ); + } + submit() { + if (!0 === this.focused.newChoice) return super.submit(); + if (this.choices.some((e) => e.newChoice)) return this.alert(); + this.value = {}; + for (let e of this.choices) { + let t = e.parent ? this.value[e.parent.name] : this.value; + 'heading' !== e.role + ? e.editable + ? (t[e.name] = e.value === e.name ? e.initial || '' : e.value) + : this.isDisabled(e) || (t[e.name] = !0 === e.enabled) + : (this.value[e.name] = {}); + } + return this.base.submit.call(this); + } + }; + }, + 71447: (e, t, r) => { + 'use strict'; + const A = r(97991), + n = r(31557), + o = r(96496); + e.exports = class extends n { + constructor(e) { + super({ ...e, multiple: !0 }), + (this.type = 'form'), + (this.initial = this.options.initial), + (this.align = [this.options.align, 'right'].find( + (e) => null != e + )), + (this.emptyError = ''), + (this.values = {}); + } + async reset(e) { + return ( + await super.reset(), + !0 === e && (this._index = this.index), + (this.index = this._index), + (this.values = {}), + this.choices.forEach((e) => e.reset && e.reset()), + this.render() + ); + } + dispatch(e) { + return !!e && this.append(e); + } + append(e) { + let t = this.focused; + if (!t) return this.alert(); + let { cursor: r, input: A } = t; + return ( + (t.value = t.input = A.slice(0, r) + e + A.slice(r)), + t.cursor++, + this.render() + ); + } + delete() { + let e = this.focused; + if (!e || e.cursor <= 0) return this.alert(); + let { cursor: t, input: r } = e; + return ( + (e.value = e.input = r.slice(0, t - 1) + r.slice(t)), + e.cursor--, + this.render() + ); + } + deleteForward() { + let e = this.focused; + if (!e) return this.alert(); + let { cursor: t, input: r } = e; + if (void 0 === r[t]) return this.alert(); + let A = ('' + r).slice(0, t) + ('' + r).slice(t + 1); + return (e.value = e.input = A), this.render(); + } + right() { + let e = this.focused; + return e + ? e.cursor >= e.input.length + ? this.alert() + : (e.cursor++, this.render()) + : this.alert(); + } + left() { + let e = this.focused; + return e + ? e.cursor <= 0 + ? this.alert() + : (e.cursor--, this.render()) + : this.alert(); + } + space(e, t) { + return this.dispatch(e, t); + } + number(e, t) { + return this.dispatch(e, t); + } + next() { + let e = this.focused; + if (!e) return this.alert(); + let { initial: t, input: r } = e; + return t && t.startsWith(r) && r !== t + ? ((e.value = e.input = t), + (e.cursor = e.value.length), + this.render()) + : super.next(); + } + prev() { + let e = this.focused; + return e + ? 0 === e.cursor + ? super.prev() + : ((e.value = e.input = ''), (e.cursor = 0), this.render()) + : this.alert(); + } + separator() { + return ''; + } + format(e) { + return this.state.submitted ? '' : super.format(e); + } + pointer() { + return ''; + } + indicator(e) { + return e.input ? '⦿' : '⊙'; + } + async choiceSeparator(e, t) { + let r = (await this.resolve(e.separator, this.state, e, t)) || ':'; + return r ? ' ' + this.styles.disabled(r) : ''; + } + async renderChoice(e, t) { + await this.onChoice(e, t); + let { state: r, styles: n } = this, + { + cursor: i, + initial: s = '', + name: a, + hint: c, + input: g = '', + } = e, + { muted: l, submitted: u, primary: h, danger: p } = n, + d = c, + C = this.index === t, + f = e.validate || (() => !0), + I = await this.choiceSeparator(e, t), + E = e.message; + 'right' === this.align && (E = E.padStart(this.longest + 1, ' ')), + 'left' === this.align && (E = E.padEnd(this.longest + 1, ' ')); + let B = (this.values[a] = g || s), + y = g ? 'success' : 'dark'; + !0 !== (await f.call(e, B, this.state)) && (y = 'danger'); + let m = (0, n[y])(await this.indicator(e, t)) + (e.pad || ''), + w = this.indent(e), + Q = () => [w, m, E + I, g, d].filter(Boolean).join(' '); + if (r.submitted) + return (E = A.unstyle(E)), (g = u(g)), (d = ''), Q(); + if (e.format) g = await e.format.call(this, g, e, t); + else { + let e = this.styles.muted; + g = o(this, { + input: g, + initial: s, + pos: i, + showCursor: C, + color: e, + }); + } + return ( + this.isValue(g) || (g = this.styles.muted(this.symbols.ellipsis)), + e.result && (this.values[a] = await e.result.call(this, B, e, t)), + C && (E = h(E)), + e.error + ? (g += (g ? ' ' : '') + p(e.error.trim())) + : e.hint && (g += (g ? ' ' : '') + l(e.hint.trim())), + Q() + ); + } + async submit() { + return (this.value = this.values), super.base.submit.call(this); + } + }; + }, + 53609: (e, t, r) => { + 'use strict'; + const A = r(10278), + n = (e, r) => { + A.defineExport(t, e, r), A.defineExport(t, e.toLowerCase(), r); + }; + n('AutoComplete', () => r(63310)), + n('BasicAuth', () => r(52810)), + n('Confirm', () => r(65742)), + n('Editable', () => r(24570)), + n('Form', () => r(71447)), + n('Input', () => r(12372)), + n('Invisible', () => r(32684)), + n('List', () => r(40876)), + n('MultiSelect', () => r(42293)), + n('Numeral', () => r(42126)), + n('Password', () => r(84697)), + n('Scale', () => r(99580)), + n('Select', () => r(31557)), + n('Snippet', () => r(98094)), + n('Sort', () => r(60042)), + n('Survey', () => r(25223)), + n('Text', () => r(97298)), + n('Toggle', () => r(41817)), + n('Quiz', () => r(88677)); + }, + 12372: (e, t, r) => { + 'use strict'; + const A = r(45853), + n = r(64083); + e.exports = class extends A { + constructor(e) { + super(e); + let t = this.options.history; + if (t && t.store) { + let e = t.values || this.initial; + (this.autosave = !!t.autosave), + (this.store = t.store), + (this.data = this.store.get('values') || { + past: [], + present: e, + }), + (this.initial = + this.data.present || + this.data.past[this.data.past.length - 1]); + } + } + completion(e) { + return this.store + ? ((this.data = n(e, this.data, this.input)), + this.data.present + ? ((this.input = this.data.present), + (this.cursor = this.input.length), + this.render()) + : this.alert()) + : this.alert(); + } + altUp() { + return this.completion('prev'); + } + altDown() { + return this.completion('next'); + } + prev() { + return this.save(), super.prev(); + } + save() { + this.store && + ((this.data = n('save', this.data, this.input)), + this.store.set('values', this.data)); + } + submit() { + return ( + this.store && !0 === this.autosave && this.save(), super.submit() + ); + } + }; + }, + 32684: (e, t, r) => { + 'use strict'; + const A = r(45853); + e.exports = class extends A { + format() { + return ''; + } + }; + }, + 40876: (e, t, r) => { + 'use strict'; + const A = r(45853); + e.exports = class extends A { + constructor(e = {}) { + super(e), + (this.sep = this.options.separator || /, */), + (this.initial = e.initial || ''); + } + split(e = this.value) { + return e ? String(e).split(this.sep) : []; + } + format() { + let e = this.state.submitted ? this.styles.primary : (e) => e; + return this.list.map(e).join(', '); + } + async submit(e) { + let t = + this.state.error || (await this.validate(this.list, this.state)); + return !0 !== t + ? ((this.state.error = t), super.submit()) + : ((this.value = this.list), super.submit()); + } + get list() { + return this.split(); + } + }; + }, + 42293: (e, t, r) => { + 'use strict'; + const A = r(31557); + e.exports = class extends A { + constructor(e) { + super({ ...e, multiple: !0 }); + } + }; + }, + 42126: (e, t, r) => { + e.exports = r(64987); + }, + 84697: (e, t, r) => { + 'use strict'; + const A = r(45853); + e.exports = class extends A { + constructor(e) { + super(e), this.cursorShow(); + } + format(e = this.input) { + if (!this.keypressed) return ''; + return (this.state.submitted + ? this.styles.primary + : this.styles.muted)(this.symbols.asterisk.repeat(e.length)); + } + }; + }, + 88677: (e, t, r) => { + 'use strict'; + const A = r(31557); + e.exports = class extends A { + constructor(e) { + if ( + (super(e), + 'number' != typeof this.options.correctChoice || + this.options.correctChoice < 0) + ) + throw new Error( + 'Please specify the index of the correct answer from the list of choices' + ); + } + async toChoices(e, t) { + let r = await super.toChoices(e, t); + if (r.length < 2) + throw new Error('Please give at least two choices to the user'); + if (this.options.correctChoice > r.length) + throw new Error( + 'Please specify the index of the correct answer from the list of choices' + ); + return r; + } + check(e) { + return e.index === this.options.correctChoice; + } + async result(e) { + return { + selectedAnswer: e, + correctAnswer: this.options.choices[this.options.correctChoice] + .value, + correct: await this.check(this.state), + }; + } + }; + }, + 99580: (e, t, r) => { + 'use strict'; + const A = r(97991), + n = r(14723), + o = r(10278); + e.exports = class extends n { + constructor(e = {}) { + super(e), + (this.widths = [].concat(e.messageWidth || 50)), + (this.align = [].concat(e.align || 'left')), + (this.linebreak = e.linebreak || !1), + (this.edgeLength = e.edgeLength || 3), + (this.newline = e.newline || '\n '); + let t = e.startNumber || 1; + 'number' == typeof this.scale && + ((this.scaleKey = !1), + (this.scale = Array(this.scale) + .fill(0) + .map((e, r) => ({ name: r + t })))); + } + async reset() { + return (this.tableized = !1), await super.reset(), this.render(); + } + tableize() { + if (!0 === this.tableized) return; + this.tableized = !0; + let e = 0; + for (let t of this.choices) { + (e = Math.max(e, t.message.length)), + (t.scaleIndex = t.initial || 2), + (t.scale = []); + for (let e = 0; e < this.scale.length; e++) + t.scale.push({ index: e }); + } + this.widths[0] = Math.min(this.widths[0], e + 3); + } + async dispatch(e, t) { + if (this.multiple) + return this[t.name] + ? await this[t.name](e, t) + : await super.dispatch(e, t); + this.alert(); + } + heading(e, t, r) { + return this.styles.strong(e); + } + separator() { + return this.styles.muted(this.symbols.ellipsis); + } + right() { + let e = this.focused; + return e.scaleIndex >= this.scale.length - 1 + ? this.alert() + : (e.scaleIndex++, this.render()); + } + left() { + let e = this.focused; + return e.scaleIndex <= 0 + ? this.alert() + : (e.scaleIndex--, this.render()); + } + indent() { + return ''; + } + format() { + if (this.state.submitted) { + return this.choices + .map((e) => this.styles.info(e.index)) + .join(', '); + } + return ''; + } + pointer() { + return ''; + } + renderScaleKey() { + if (!1 === this.scaleKey) return ''; + if (this.state.submitted) return ''; + return ['', ...this.scale.map((e) => ` ${e.name} - ${e.message}`)] + .map((e) => this.styles.muted(e)) + .join('\n'); + } + renderScaleHeading(e) { + let t = this.scale.map((e) => e.name); + 'function' == typeof this.options.renderScaleHeading && + (t = this.options.renderScaleHeading.call(this, e)); + let r = this.scaleLength - t.join('').length, + A = Math.round(r / (t.length - 1)), + n = t.map((e) => this.styles.strong(e)).join(' '.repeat(A)), + o = ' '.repeat(this.widths[0]); + return this.margin[3] + o + this.margin[1] + n; + } + scaleIndicator(e, t, r) { + if ('function' == typeof this.options.scaleIndicator) + return this.options.scaleIndicator.call(this, e, t, r); + let A = e.scaleIndex === t.index; + return t.disabled + ? this.styles.hint(this.symbols.radio.disabled) + : A + ? this.styles.success(this.symbols.radio.on) + : this.symbols.radio.off; + } + renderScale(e, t) { + let r = e.scale.map((r) => this.scaleIndicator(e, r, t)), + A = 'Hyper' === this.term ? '' : ' '; + return r.join(A + this.symbols.line.repeat(this.edgeLength)); + } + async renderChoice(e, t) { + await this.onChoice(e, t); + let r = this.index === t, + n = await this.pointer(e, t), + i = await e.hint; + i && !o.hasColor(i) && (i = this.styles.muted(i)); + let s = (e) => + this.margin[3] + + e.replace(/\s+$/, '').padEnd(this.widths[0], ' '), + a = this.newline, + c = this.indent(e), + g = await this.resolve(e.message, this.state, e, t), + l = await this.renderScale(e, t), + u = this.margin[1] + this.margin[3]; + (this.scaleLength = A.unstyle(l).length), + (this.widths[0] = Math.min( + this.widths[0], + this.width - this.scaleLength - u.length + )); + let h = o + .wordWrap(g, { width: this.widths[0], newline: a }) + .split('\n') + .map((e) => s(e) + this.margin[1]); + return ( + r && + ((l = this.styles.info(l)), + (h = h.map((e) => this.styles.info(e)))), + (h[0] += l), + this.linebreak && h.push(''), + [c + n, h.join('\n')].filter(Boolean) + ); + } + async renderChoices() { + if (this.state.submitted) return ''; + this.tableize(); + let e = this.visible.map( + async (e, t) => await this.renderChoice(e, t) + ), + t = await Promise.all(e), + r = await this.renderScaleHeading(); + return ( + this.margin[0] + [r, ...t.map((e) => e.join(' '))].join('\n') + ); + } + async render() { + let { submitted: e, size: t } = this.state, + r = await this.prefix(), + A = await this.separator(), + n = await this.message(), + o = ''; + !1 !== this.options.promptLine && + ((o = [r, n, A, ''].join(' ')), (this.state.prompt = o)); + let i = await this.header(), + s = await this.format(), + a = await this.renderScaleKey(), + c = (await this.error()) || (await this.hint()), + g = await this.renderChoices(), + l = await this.footer(), + u = this.emptyError; + s && (o += s), + c && !o.includes(c) && (o += ' ' + c), + e && + !s && + !g.trim() && + this.multiple && + null != u && + (o += this.styles.danger(u)), + this.clear(t), + this.write([i, o, a, g, l].filter(Boolean).join('\n')), + this.state.submitted || this.write(this.margin[2]), + this.restore(); + } + submit() { + this.value = {}; + for (let e of this.choices) this.value[e.name] = e.scaleIndex; + return this.base.submit.call(this); + } + }; + }, + 31557: (e, t, r) => { + 'use strict'; + const A = r(14723), + n = r(10278); + e.exports = class extends A { + constructor(e) { + super(e), + (this.emptyError = + this.options.emptyError || 'No items were selected'); + } + async dispatch(e, t) { + if (this.multiple) + return this[t.name] + ? await this[t.name](e, t) + : await super.dispatch(e, t); + this.alert(); + } + separator() { + if (this.options.separator) return super.separator(); + let e = this.styles.muted(this.symbols.ellipsis); + return this.state.submitted ? super.separator() : e; + } + pointer(e, t) { + return !this.multiple || this.options.pointer + ? super.pointer(e, t) + : ''; + } + indicator(e, t) { + return this.multiple ? super.indicator(e, t) : ''; + } + choiceMessage(e, t) { + let r = this.resolve(e.message, this.state, e, t); + return ( + 'heading' !== e.role || + n.hasColor(r) || + (r = this.styles.strong(r)), + this.resolve(r, this.state, e, t) + ); + } + choiceSeparator() { + return ':'; + } + async renderChoice(e, t) { + await this.onChoice(e, t); + let r = this.index === t, + A = await this.pointer(e, t), + o = (await this.indicator(e, t)) + (e.pad || ''), + i = await this.resolve(e.hint, this.state, e, t); + i && !n.hasColor(i) && (i = this.styles.muted(i)); + let s = this.indent(e), + a = await this.choiceMessage(e, t), + c = () => + [this.margin[3], s + A + o, a, this.margin[1], i] + .filter(Boolean) + .join(' '); + return 'heading' === e.role + ? c() + : e.disabled + ? (n.hasColor(a) || (a = this.styles.disabled(a)), c()) + : (r && (a = this.styles.em(a)), c()); + } + async renderChoices() { + if ('choices' === this.state.loading) + return this.styles.warning('Loading choices'); + if (this.state.submitted) return ''; + let e = this.visible.map( + async (e, t) => await this.renderChoice(e, t) + ), + t = await Promise.all(e); + t.length || t.push(this.styles.danger('No matching choices')); + let r, + A = this.margin[0] + t.join('\n'); + return ( + this.options.choicesHeader && + (r = await this.resolve( + this.options.choicesHeader, + this.state + )), + [r, A].filter(Boolean).join('\n') + ); + } + format() { + return !this.state.submitted || this.state.cancelled + ? '' + : Array.isArray(this.selected) + ? this.selected.map((e) => this.styles.primary(e.name)).join(', ') + : this.styles.primary(this.selected.name); + } + async render() { + let { submitted: e, size: t } = this.state, + r = '', + A = await this.header(), + n = await this.prefix(), + o = await this.separator(), + i = await this.message(); + !1 !== this.options.promptLine && + ((r = [n, i, o, ''].join(' ')), (this.state.prompt = r)); + let s = await this.format(), + a = (await this.error()) || (await this.hint()), + c = await this.renderChoices(), + g = await this.footer(); + s && (r += s), + a && !r.includes(a) && (r += ' ' + a), + e && + !s && + !c.trim() && + this.multiple && + null != this.emptyError && + (r += this.styles.danger(this.emptyError)), + this.clear(t), + this.write([A, r, c, g].filter(Boolean).join('\n')), + this.write(this.margin[2]), + this.restore(); + } + }; + }, + 98094: (e, t, r) => { + 'use strict'; + const A = r(97991), + n = r(84368), + o = r(58386); + e.exports = class extends o { + constructor(e) { + super(e), this.cursorHide(), this.reset(!0); + } + async initialize() { + (this.interpolate = await n(this)), await super.initialize(); + } + async reset(e) { + (this.state.keys = []), + (this.state.invalid = new Map()), + (this.state.missing = new Set()), + (this.state.completed = 0), + (this.state.values = {}), + !0 !== e && (await this.initialize(), await this.render()); + } + moveCursor(e) { + let t = this.getItem(); + (this.cursor += e), (t.cursor += e); + } + dispatch(e, t) { + t.code || t.ctrl || null == e || !this.getItem() + ? this.alert() + : this.append(e, t); + } + append(e, t) { + let r = this.getItem(), + A = r.input.slice(0, this.cursor), + n = r.input.slice(this.cursor); + (this.input = r.input = `${A}${e}${n}`), + this.moveCursor(1), + this.render(); + } + delete() { + let e = this.getItem(); + if (this.cursor <= 0 || !e.input) return this.alert(); + let t = e.input.slice(this.cursor), + r = e.input.slice(0, this.cursor - 1); + (this.input = e.input = `${r}${t}`), + this.moveCursor(-1), + this.render(); + } + increment(e) { + return e >= this.state.keys.length - 1 ? 0 : e + 1; + } + decrement(e) { + return e <= 0 ? this.state.keys.length - 1 : e - 1; + } + first() { + (this.state.index = 0), this.render(); + } + last() { + (this.state.index = this.state.keys.length - 1), this.render(); + } + right() { + if (this.cursor >= this.input.length) return this.alert(); + this.moveCursor(1), this.render(); + } + left() { + if (this.cursor <= 0) return this.alert(); + this.moveCursor(-1), this.render(); + } + prev() { + (this.state.index = this.decrement(this.state.index)), + this.getItem(), + this.render(); + } + next() { + (this.state.index = this.increment(this.state.index)), + this.getItem(), + this.render(); + } + up() { + this.prev(); + } + down() { + this.next(); + } + format(e) { + let t = + this.state.completed < 100 + ? this.styles.warning + : this.styles.success; + return ( + !0 === this.state.submitted && + 100 !== this.state.completed && + (t = this.styles.danger), + t(this.state.completed + '% completed') + ); + } + async render() { + let { index: e, keys: t = [], submitted: r, size: A } = this.state, + n = [this.options.newline, '\n'].find((e) => null != e), + o = await this.prefix(), + i = await this.separator(), + s = [o, await this.message(), i].filter(Boolean).join(' '); + this.state.prompt = s; + let a = await this.header(), + c = (await this.error()) || '', + g = (await this.hint()) || '', + l = r ? '' : await this.interpolate(this.state), + u = (this.state.key = t[e] || ''), + h = await this.format(u), + p = await this.footer(); + h && (s += ' ' + h), + g && !h && 0 === this.state.completed && (s += ' ' + g), + this.clear(A); + let d = [a, s, l, p, c.trim()]; + this.write(d.filter(Boolean).join(n)), this.restore(); + } + getItem(e) { + let { items: t, keys: r, index: A } = this.state, + n = t.find((e) => e.name === r[A]); + return ( + n && + null != n.input && + ((this.input = n.input), (this.cursor = n.cursor)), + n + ); + } + async submit() { + 'function' != typeof this.interpolate && (await this.initialize()), + await this.interpolate(this.state, !0); + let { invalid: e, missing: t, output: r, values: n } = this.state; + if (e.size) { + let t = ''; + for (let [r, A] of e) t += `Invalid ${r}: ${A}\n`; + return (this.state.error = t), super.submit(); + } + if (t.size) + return ( + (this.state.error = 'Required: ' + [...t.keys()].join(', ')), + super.submit() + ); + let o = A.unstyle(r) + .split('\n') + .map((e) => e.slice(1)) + .join('\n'); + return (this.value = { values: n, result: o }), super.submit(); + } + }; + }, + 60042: (e, t, r) => { + 'use strict'; + const A = '(Use + to sort)', + n = r(31557); + e.exports = class extends n { + constructor(e) { + super({ ...e, reorder: !1, sort: !0, multiple: !0 }), + (this.state.hint = [this.options.hint, A].find( + this.isValue.bind(this) + )); + } + indicator() { + return ''; + } + async renderChoice(e, t) { + let r = await super.renderChoice(e, t), + A = this.symbols.identicalTo + ' ', + n = + this.index === t && this.sorting ? this.styles.muted(A) : ' '; + return ( + !1 === this.options.drag && (n = ''), + !0 === this.options.numbered ? n + (t + 1 + ' - ') + r : n + r + ); + } + get selected() { + return this.choices; + } + submit() { + return ( + (this.value = this.choices.map((e) => e.value)), super.submit() + ); + } + }; + }, + 25223: (e, t, r) => { + 'use strict'; + const A = r(14723); + function n(e, t = {}) { + if (Array.isArray(t.scale)) return t.scale.map((e) => ({ ...e })); + let r = []; + for (let t = 1; t < e + 1; t++) r.push({ i: t, selected: !1 }); + return r; + } + e.exports = class extends A { + constructor(e = {}) { + if ( + (super(e), + (this.emptyError = e.emptyError || 'No items were selected'), + (this.term = process.env.TERM_PROGRAM), + !this.options.header) + ) { + let e = [ + '', + '4 - Strongly Agree', + '3 - Agree', + '2 - Neutral', + '1 - Disagree', + '0 - Strongly Disagree', + '', + ]; + (e = e.map((e) => this.styles.muted(e))), + (this.state.header = e.join('\n ')); + } + } + async toChoices(...e) { + if (this.createdScales) return !1; + this.createdScales = !0; + let t = await super.toChoices(...e); + for (let e of t) (e.scale = n(5, this.options)), (e.scaleIdx = 2); + return t; + } + dispatch() { + this.alert(); + } + space() { + let e = this.focused, + t = e.scale[e.scaleIdx], + r = t.selected; + return ( + e.scale.forEach((e) => (e.selected = !1)), + (t.selected = !r), + this.render() + ); + } + indicator() { + return ''; + } + pointer() { + return ''; + } + separator() { + return this.styles.muted(this.symbols.ellipsis); + } + right() { + let e = this.focused; + return e.scaleIdx >= e.scale.length - 1 + ? this.alert() + : (e.scaleIdx++, this.render()); + } + left() { + let e = this.focused; + return e.scaleIdx <= 0 + ? this.alert() + : (e.scaleIdx--, this.render()); + } + indent() { + return ' '; + } + async renderChoice(e, t) { + await this.onChoice(e, t); + let r = this.index === t, + A = 'Hyper' === this.term, + n = A ? 9 : 8, + o = A ? '' : ' ', + i = this.symbols.line.repeat(n), + s = ' '.repeat(n + (A ? 0 : 1)), + a = (e) => (e ? this.styles.success('◉') : '◯') + o, + c = t + 1 + '.', + g = r ? this.styles.heading : this.styles.noop, + l = await this.resolve(e.message, this.state, e, t), + u = this.indent(e), + h = u + e.scale.map((t, r) => a(r === e.scaleIdx)).join(i), + p = + u + + e.scale + .map((t, r) => ((t) => (t === e.scaleIdx ? g(t) : t))(r)) + .join(s); + return ( + r && ((h = this.styles.cyan(h)), (p = this.styles.cyan(p))), + [[c, l].filter(Boolean).join(' '), h, p, ' '] + .filter(Boolean) + .join('\n') + ); + } + async renderChoices() { + if (this.state.submitted) return ''; + let e = this.visible.map( + async (e, t) => await this.renderChoice(e, t) + ), + t = await Promise.all(e); + return ( + t.length || t.push(this.styles.danger('No matching choices')), + t.join('\n') + ); + } + format() { + if (this.state.submitted) { + return this.choices + .map((e) => this.styles.info(e.scaleIdx)) + .join(', '); + } + return ''; + } + async render() { + let { submitted: e, size: t } = this.state, + r = await this.prefix(), + A = await this.separator(), + n = [r, await this.message(), A].filter(Boolean).join(' '); + this.state.prompt = n; + let o = await this.header(), + i = await this.format(), + s = (await this.error()) || (await this.hint()), + a = await this.renderChoices(), + c = await this.footer(); + (!i && s) || (n += ' ' + i), + s && !n.includes(s) && (n += ' ' + s), + e && + !i && + !a && + this.multiple && + 'form' !== this.type && + (n += this.styles.danger(this.emptyError)), + this.clear(t), + this.write([n, o, a, c].filter(Boolean).join('\n')), + this.restore(); + } + submit() { + this.value = {}; + for (let e of this.choices) this.value[e.name] = e.scaleIdx; + return this.base.submit.call(this); + } + }; + }, + 97298: (e, t, r) => { + e.exports = r(12372); + }, + 41817: (e, t, r) => { + 'use strict'; + const A = r(82710); + e.exports = class extends A { + async initialize() { + await super.initialize(), + (this.value = this.initial = !!this.options.initial), + (this.disabled = this.options.disabled || 'no'), + (this.enabled = this.options.enabled || 'yes'), + await this.render(); + } + reset() { + (this.value = this.initial), this.render(); + } + delete() { + this.alert(); + } + toggle() { + (this.value = !this.value), this.render(); + } + enable() { + if (!0 === this.value) return this.alert(); + (this.value = !0), this.render(); + } + disable() { + if (!1 === this.value) return this.alert(); + (this.value = !1), this.render(); + } + up() { + this.toggle(); + } + down() { + this.toggle(); + } + right() { + this.toggle(); + } + left() { + this.toggle(); + } + next() { + this.toggle(); + } + prev() { + this.toggle(); + } + dispatch(e = '', t) { + switch (e.toLowerCase()) { + case ' ': + return this.toggle(); + case '1': + case 'y': + case 't': + return this.enable(); + case '0': + case 'n': + case 'f': + return this.disable(); + default: + return this.alert(); + } + } + format() { + let e = (e) => this.styles.primary.underline(e); + return [ + this.value ? this.disabled : e(this.disabled), + this.value ? e(this.enabled) : this.enabled, + ].join(this.styles.muted(' / ')); + } + async render() { + let { size: e } = this.state, + t = await this.header(), + r = await this.prefix(), + A = await this.separator(), + n = await this.message(), + o = await this.format(), + i = (await this.error()) || (await this.hint()), + s = await this.footer(), + a = [r, n, A, o].join(' '); + (this.state.prompt = a), + i && !a.includes(i) && (a += ' ' + i), + this.clear(e), + this.write([t, a, s].filter(Boolean).join('\n')), + this.write(this.margin[2]), + this.restore(); + } + }; + }, + 27011: (e, t, r) => { + 'use strict'; + const A = r(10278), + n = { + default: (e, t) => t, + checkbox(e, t) { + throw new Error('checkbox role is not implemented yet'); + }, + editable(e, t) { + throw new Error('editable role is not implemented yet'); + }, + expandable(e, t) { + throw new Error('expandable role is not implemented yet'); + }, + heading: (e, t) => ( + (t.disabled = ''), + (t.indicator = [t.indicator, ' '].find((e) => null != e)), + (t.message = t.message || ''), + t + ), + input(e, t) { + throw new Error('input role is not implemented yet'); + }, + option: (e, t) => n.default(e, t), + radio(e, t) { + throw new Error('radio role is not implemented yet'); + }, + separator: (e, t) => ( + (t.disabled = ''), + (t.indicator = [t.indicator, ' '].find((e) => null != e)), + (t.message = t.message || e.symbols.line.repeat(5)), + t + ), + spacer: (e, t) => t, + }; + e.exports = (e, t = {}) => { + let r = A.merge({}, n, t.roles); + return r[e] || r.default; + }; + }, + 61807: (e, t, r) => { + 'use strict'; + const { define: A, width: n } = r(10278); + e.exports = class { + constructor(e) { + let t = e.options; + A(this, '_prompt', e), + (this.type = e.type), + (this.name = e.name), + (this.message = ''), + (this.header = ''), + (this.footer = ''), + (this.error = ''), + (this.hint = ''), + (this.input = ''), + (this.cursor = 0), + (this.index = 0), + (this.lines = 0), + (this.tick = 0), + (this.prompt = ''), + (this.buffer = ''), + (this.width = n(t.stdout || process.stdout)), + Object.assign(this, t), + (this.name = this.name || this.message), + (this.message = this.message || this.name), + (this.symbols = e.symbols), + (this.styles = e.styles), + (this.required = new Set()), + (this.cancelled = !1), + (this.submitted = !1); + } + clone() { + let e = { ...this }; + return ( + (e.status = this.status), + (e.buffer = Buffer.from(e.buffer)), + delete e.clone, + e + ); + } + set color(e) { + this._color = e; + } + get color() { + let e = this.prompt.styles; + if (this.cancelled) return e.cancelled; + if (this.submitted) return e.submitted; + let t = this._color || e[this.status]; + return 'function' == typeof t ? t : e.pending; + } + set loading(e) { + this._loading = e; + } + get loading() { + return 'boolean' == typeof this._loading + ? this._loading + : !!this.loadingChoices && 'choices'; + } + get status() { + return this.cancelled + ? 'cancelled' + : this.submitted + ? 'submitted' + : 'pending'; + } + }; + }, + 64402: (e, t, r) => { + 'use strict'; + const A = r(10278), + n = r(97991), + o = { + default: n.noop, + noop: n.noop, + set inverse(e) { + this._inverse = e; + }, + get inverse() { + return this._inverse || A.inverse(this.primary); + }, + set complement(e) { + this._complement = e; + }, + get complement() { + return this._complement || A.complement(this.primary); + }, + primary: n.cyan, + success: n.green, + danger: n.magenta, + strong: n.bold, + warning: n.yellow, + muted: n.dim, + disabled: n.gray, + dark: n.dim.gray, + underline: n.underline, + set info(e) { + this._info = e; + }, + get info() { + return this._info || this.primary; + }, + set em(e) { + this._em = e; + }, + get em() { + return this._em || this.primary.underline; + }, + set heading(e) { + this._heading = e; + }, + get heading() { + return this._heading || this.muted.underline; + }, + set pending(e) { + this._pending = e; + }, + get pending() { + return this._pending || this.primary; + }, + set submitted(e) { + this._submitted = e; + }, + get submitted() { + return this._submitted || this.success; + }, + set cancelled(e) { + this._cancelled = e; + }, + get cancelled() { + return this._cancelled || this.danger; + }, + set typing(e) { + this._typing = e; + }, + get typing() { + return this._typing || this.dim; + }, + set placeholder(e) { + this._placeholder = e; + }, + get placeholder() { + return this._placeholder || this.primary.dim; + }, + set highlight(e) { + this._highlight = e; + }, + get highlight() { + return this._highlight || this.inverse; + }, + merge: (e = {}) => { + e.styles && + 'boolean' == typeof e.styles.enabled && + (n.enabled = e.styles.enabled), + e.styles && + 'boolean' == typeof e.styles.visible && + (n.visible = e.styles.visible); + let t = A.merge({}, o, e.styles); + delete t.merge; + for (let e of Object.keys(n)) + t.hasOwnProperty(e) || + Reflect.defineProperty(t, e, { get: () => n[e] }); + for (let e of Object.keys(n.styles)) + t.hasOwnProperty(e) || + Reflect.defineProperty(t, e, { get: () => n[e] }); + return t; + }, + }; + e.exports = o; + }, + 50511: (e, t, r) => { + 'use strict'; + const A = 'win32' === process.platform, + n = r(97991), + o = r(10278), + i = { + ...n.symbols, + upDownDoubleArrow: '⇕', + upDownDoubleArrow2: '⬍', + upDownArrow: '↕', + asterisk: '*', + asterism: '⁂', + bulletWhite: '◦', + electricArrow: '⌁', + ellipsisLarge: '⋯', + ellipsisSmall: '…', + fullBlock: '█', + identicalTo: '≡', + indicator: n.symbols.check, + leftAngle: '‹', + mark: '※', + minus: '−', + multiplication: '×', + obelus: '÷', + percent: '%', + pilcrow: '¶', + pilcrow2: '❡', + pencilUpRight: '✐', + pencilDownRight: '✎', + pencilRight: '✏', + plus: '+', + plusMinus: '±', + pointRight: '☞', + rightAngle: '›', + section: '§', + hexagon: { off: '⬡', on: '⬢', disabled: '⬢' }, + ballot: { on: '☑', off: '☐', disabled: '☒' }, + stars: { on: '★', off: '☆', disabled: '☆' }, + folder: { on: '▼', off: '▶', disabled: '▶' }, + prefix: { + pending: n.symbols.question, + submitted: n.symbols.check, + cancelled: n.symbols.cross, + }, + separator: { + pending: n.symbols.pointerSmall, + submitted: n.symbols.middot, + cancelled: n.symbols.middot, + }, + radio: { + off: A ? '( )' : '◯', + on: A ? '(*)' : '◉', + disabled: A ? '(|)' : 'Ⓘ', + }, + numbers: [ + '⓪', + '①', + '②', + '③', + '④', + '⑤', + '⑥', + '⑦', + '⑧', + '⑨', + '⑩', + '⑪', + '⑫', + '⑬', + '⑭', + '⑮', + '⑯', + '⑰', + '⑱', + '⑲', + '⑳', + '㉑', + '㉒', + '㉓', + '㉔', + '㉕', + '㉖', + '㉗', + '㉘', + '㉙', + '㉚', + '㉛', + '㉜', + '㉝', + '㉞', + '㉟', + '㊱', + '㊲', + '㊳', + '㊴', + '㊵', + '㊶', + '㊷', + '㊸', + '㊹', + '㊺', + '㊻', + '㊼', + '㊽', + '㊾', + '㊿', + ], + }; + (i.merge = (e) => { + let t = o.merge({}, n.symbols, i, e.symbols); + return delete t.merge, t; + }), + (e.exports = i); + }, + 26205: (e, t, r) => { + 'use strict'; + const A = r(64402), + n = r(50511), + o = r(10278); + e.exports = (e) => { + (e.options = o.merge({}, e.options.theme, e.options)), + (e.symbols = n.merge(e.options)), + (e.styles = A.merge(e.options)); + }; + }, + 47159: (e) => { + 'use strict'; + function t(e, t, r = {}) { + let A = (e.timers[t] = { + name: t, + start: Date.now(), + ms: 0, + tick: 0, + }), + n = r.interval || 120; + (A.frames = r.frames || []), (A.loading = !0); + let o = setInterval(() => { + (A.ms = Date.now() - A.start), A.tick++, e.render(); + }, n); + return ( + (A.stop = () => { + (A.loading = !1), clearInterval(o); + }), + Reflect.defineProperty(A, 'interval', { value: o }), + e.once('close', () => A.stop()), + A.stop + ); + } + e.exports = (e) => { + e.timers = e.timers || {}; + let r = e.options.timers; + if (r) + for (let A of Object.keys(r)) { + let n = r[A]; + 'number' == typeof n && (n = { interval: n }), t(e, A, n); + } + }; + }, + 14723: (e, t, r) => { + 'use strict'; + const A = r(97991), + n = r(58386), + o = r(27011), + i = r(10278), + { reorder: s, scrollUp: a, scrollDown: c, isObject: g, swap: l } = i; + function u(e, t) { + if (t instanceof Promise) return t; + if ('function' == typeof t) { + if (i.isAsyncFn(t)) return t; + t = t.call(e, e); + } + for (let r of t) { + if (Array.isArray(r.choices)) { + let t = r.choices.filter((t) => !e.isDisabled(t)); + r.enabled = t.every((e) => !0 === e.enabled); + } + !0 === e.isDisabled(r) && delete r.enabled; + } + return t; + } + e.exports = class extends n { + constructor(e) { + super(e), + this.cursorHide(), + (this.maxSelected = e.maxSelected || 1 / 0), + (this.multiple = e.multiple || !1), + (this.initial = e.initial || 0), + (this.delay = e.delay || 0), + (this.longest = 0), + (this.num = ''); + } + async initialize() { + 'function' == typeof this.options.initial && + (this.initial = await this.options.initial.call(this)), + await this.reset(!0), + await super.initialize(); + } + async reset() { + let { + choices: e, + initial: t, + autofocus: r, + suggest: A, + } = this.options; + if ( + ((this.state._choices = []), + (this.state.choices = []), + (this.choices = await Promise.all(await this.toChoices(e))), + this.choices.forEach((e) => (e.enabled = !1)), + 'function' != typeof A && 0 === this.selectable.length) + ) + throw new Error('At least one choice must be selectable'); + g(t) && (t = Object.keys(t)), + Array.isArray(t) + ? (null != r && (this.index = this.findIndex(r)), + t.forEach((e) => this.enable(this.find(e))), + await this.render()) + : (null != r && (t = r), + 'string' == typeof t && (t = this.findIndex(t)), + 'number' == typeof t && + t > -1 && + ((this.index = Math.max( + 0, + Math.min(t, this.choices.length) + )), + this.enable(this.find(this.index)))), + this.isDisabled(this.focused) && (await this.down()); + } + async toChoices(e, t) { + this.state.loadingChoices = !0; + let r = [], + A = 0, + n = async (e, t) => { + 'function' == typeof e && (e = await e.call(this)), + e instanceof Promise && (e = await e); + for (let o = 0; o < e.length; o++) { + let i = (e[o] = await this.toChoice(e[o], A++, t)); + r.push(i), i.choices && (await n(i.choices, i)); + } + return r; + }; + return n(e, t).then((e) => ((this.state.loadingChoices = !1), e)); + } + async toChoice(e, t, r) { + if ( + ('function' == typeof e && (e = await e.call(this, this)), + e instanceof Promise && (e = await e), + 'string' == typeof e && (e = { name: e }), + e.normalized) + ) + return e; + e.normalized = !0; + let n = e.value, + s = o(e.role, this.options); + if ( + ('string' != typeof (e = s(this, e)).disabled || + e.hint || + ((e.hint = e.disabled), (e.disabled = !0)), + !0 === e.disabled && null == e.hint && (e.hint = '(disabled)'), + null != e.index) + ) + return e; + (e.name = e.name || e.key || e.title || e.value || e.message), + (e.message = e.message || e.name || ''), + (e.value = [e.value, e.name].find(this.isValue.bind(this))), + (e.input = ''), + (e.index = t), + (e.cursor = 0), + i.define(e, 'parent', r), + (e.level = r ? r.level + 1 : 1), + null == e.indent && + (e.indent = r ? r.indent + ' ' : e.indent || ''), + (e.path = r ? r.path + '.' + e.name : e.name), + (e.enabled = !( + !this.multiple || + this.isDisabled(e) || + (!e.enabled && !this.isSelected(e)) + )), + this.isDisabled(e) || + (this.longest = Math.max( + this.longest, + A.unstyle(e.message).length + )); + let a = { ...e }; + return ( + (e.reset = (t = a.input, r = a.value) => { + for (let t of Object.keys(a)) e[t] = a[t]; + (e.input = t), (e.value = r); + }), + null == n && + 'function' == typeof e.initial && + (e.input = await e.initial.call(this, this.state, e, t)), + e + ); + } + async onChoice(e, t) { + this.emit('choice', e, t, this), + 'function' == typeof e.onChoice && + (await e.onChoice.call(this, this.state, e, t)); + } + async addChoice(e, t, r) { + let A = await this.toChoice(e, t, r); + return ( + this.choices.push(A), + (this.index = this.choices.length - 1), + (this.limit = this.choices.length), + A + ); + } + async newItem(e, t, r) { + let A = { + name: 'New choice name?', + editable: !0, + newChoice: !0, + ...e, + }, + n = await this.addChoice(A, t, r); + return ( + (n.updateChoice = () => { + delete n.newChoice, + (n.name = n.message = n.input), + (n.input = ''), + (n.cursor = 0); + }), + this.render() + ); + } + indent(e) { + return null == e.indent + ? e.level > 1 + ? ' '.repeat(e.level - 1) + : '' + : e.indent; + } + dispatch(e, t) { + if (this.multiple && this[t.name]) return this[t.name](); + this.alert(); + } + focus(e, t) { + return ( + 'boolean' != typeof t && (t = e.enabled), + t && !e.enabled && this.selected.length >= this.maxSelected + ? this.alert() + : ((this.index = e.index), + (e.enabled = t && !this.isDisabled(e)), + e) + ); + } + space() { + return this.multiple + ? (this.toggle(this.focused), this.render()) + : this.alert(); + } + a() { + if (this.maxSelected < this.choices.length) return this.alert(); + let e = this.selectable.every((e) => e.enabled); + return this.choices.forEach((t) => (t.enabled = !e)), this.render(); + } + i() { + return this.choices.length - this.selected.length > this.maxSelected + ? this.alert() + : (this.choices.forEach((e) => (e.enabled = !e.enabled)), + this.render()); + } + g(e = this.focused) { + return this.choices.some((e) => !!e.parent) + ? (this.toggle(e.parent && !e.choices ? e.parent : e), + this.render()) + : this.a(); + } + toggle(e, t) { + if (!e.enabled && this.selected.length >= this.maxSelected) + return this.alert(); + 'boolean' != typeof t && (t = !e.enabled), + (e.enabled = t), + e.choices && e.choices.forEach((e) => this.toggle(e, t)); + let r = e.parent; + for (; r; ) { + let e = r.choices.filter((e) => this.isDisabled(e)); + (r.enabled = e.every((e) => !0 === e.enabled)), (r = r.parent); + } + return u(this, this.choices), this.emit('toggle', e, this), e; + } + enable(e) { + return this.selected.length >= this.maxSelected + ? this.alert() + : ((e.enabled = !this.isDisabled(e)), + e.choices && e.choices.forEach(this.enable.bind(this)), + e); + } + disable(e) { + return ( + (e.enabled = !1), + e.choices && e.choices.forEach(this.disable.bind(this)), + e + ); + } + number(e) { + this.num += e; + let t = (e) => { + let t = Number(e); + if (t > this.choices.length - 1) return this.alert(); + let r = this.focused, + A = this.choices.find((e) => t === e.index); + if (!A.enabled && this.selected.length >= this.maxSelected) + return this.alert(); + if (-1 === this.visible.indexOf(A)) { + let e = s(this.choices), + t = e.indexOf(A); + if (r.index > t) { + let r = e.slice(t, t + this.limit), + A = e.filter((e) => !r.includes(e)); + this.choices = r.concat(A); + } else { + let r = t - this.limit + 1; + this.choices = e.slice(r).concat(e.slice(0, r)); + } + } + return ( + (this.index = this.choices.indexOf(A)), + this.toggle(this.focused), + this.render() + ); + }; + return ( + clearTimeout(this.numberTimeout), + new Promise((e) => { + let r = this.choices.length, + A = this.num, + n = (r = !1, n) => { + clearTimeout(this.numberTimeout), + r && (n = t(A)), + (this.num = ''), + e(n); + }; + return '0' === A || (1 === A.length && Number(A + '0') > r) + ? n(!0) + : Number(A) > r + ? n(!1, this.alert()) + : void (this.numberTimeout = setTimeout( + () => n(!0), + this.delay + )); + }) + ); + } + home() { + return ( + (this.choices = s(this.choices)), (this.index = 0), this.render() + ); + } + end() { + let e = this.choices.length - this.limit, + t = s(this.choices); + return ( + (this.choices = t.slice(e).concat(t.slice(0, e))), + (this.index = this.limit - 1), + this.render() + ); + } + first() { + return (this.index = 0), this.render(); + } + last() { + return (this.index = this.visible.length - 1), this.render(); + } + prev() { + return this.visible.length <= 1 ? this.alert() : this.up(); + } + next() { + return this.visible.length <= 1 ? this.alert() : this.down(); + } + right() { + return this.cursor >= this.input.length + ? this.alert() + : (this.cursor++, this.render()); + } + left() { + return this.cursor <= 0 + ? this.alert() + : (this.cursor--, this.render()); + } + up() { + let e = this.choices.length, + t = this.visible.length, + r = this.index; + return !1 === this.options.scroll && 0 === r + ? this.alert() + : e > t && 0 === r + ? this.scrollUp() + : ((this.index = (r - (1 % e) + e) % e), + this.isDisabled() ? this.up() : this.render()); + } + down() { + let e = this.choices.length, + t = this.visible.length, + r = this.index; + return !1 === this.options.scroll && r === t - 1 + ? this.alert() + : e > t && r === t - 1 + ? this.scrollDown() + : ((this.index = (r + 1) % e), + this.isDisabled() ? this.down() : this.render()); + } + scrollUp(e = 0) { + return ( + (this.choices = a(this.choices)), + (this.index = e), + this.isDisabled() ? this.up() : this.render() + ); + } + scrollDown(e = this.visible.length - 1) { + return ( + (this.choices = c(this.choices)), + (this.index = e), + this.isDisabled() ? this.down() : this.render() + ); + } + async shiftUp() { + return !0 === this.options.sort + ? ((this.sorting = !0), + this.swap(this.index - 1), + await this.up(), + void (this.sorting = !1)) + : this.scrollUp(this.index); + } + async shiftDown() { + return !0 === this.options.sort + ? ((this.sorting = !0), + this.swap(this.index + 1), + await this.down(), + void (this.sorting = !1)) + : this.scrollDown(this.index); + } + pageUp() { + return this.visible.length <= 1 + ? this.alert() + : ((this.limit = Math.max(this.limit - 1, 0)), + (this.index = Math.min(this.limit - 1, this.index)), + (this._limit = this.limit), + this.isDisabled() ? this.up() : this.render()); + } + pageDown() { + return this.visible.length >= this.choices.length + ? this.alert() + : ((this.index = Math.max(0, this.index)), + (this.limit = Math.min(this.limit + 1, this.choices.length)), + (this._limit = this.limit), + this.isDisabled() ? this.down() : this.render()); + } + swap(e) { + l(this.choices, this.index, e); + } + isDisabled(e = this.focused) { + return ( + !( + !e || + ![ + 'disabled', + 'collapsed', + 'hidden', + 'completing', + 'readonly', + ].some((t) => !0 === e[t]) + ) || + (e && 'heading' === e.role) + ); + } + isEnabled(e = this.focused) { + if (Array.isArray(e)) return e.every((e) => this.isEnabled(e)); + if (e.choices) { + let t = e.choices.filter((e) => !this.isDisabled(e)); + return e.enabled && t.every((e) => this.isEnabled(e)); + } + return e.enabled && !this.isDisabled(e); + } + isChoice(e, t) { + return e.name === t || e.index === Number(t); + } + isSelected(e) { + return Array.isArray(this.initial) + ? this.initial.some((t) => this.isChoice(e, t)) + : this.isChoice(e, this.initial); + } + map(e = [], t = 'value') { + return [] + .concat(e || []) + .reduce((e, r) => ((e[r] = this.find(r, t)), e), {}); + } + filter(e, t) { + let r = + 'function' == typeof e ? e : (t, r) => [t.name, r].includes(e), + A = (this.options.multiple + ? this.state._choices + : this.choices + ).filter(r); + return t ? A.map((e) => e[t]) : A; + } + find(e, t) { + if (g(e)) return t ? e[t] : e; + let r = + 'function' == typeof e ? e : (t, r) => [t.name, r].includes(e), + A = this.choices.find(r); + return A ? (t ? A[t] : A) : void 0; + } + findIndex(e) { + return this.choices.indexOf(this.find(e)); + } + async submit() { + let e = this.focused; + if (!e) return this.alert(); + if (e.newChoice) + return e.input ? (e.updateChoice(), this.render()) : this.alert(); + if (this.choices.some((e) => e.newChoice)) return this.alert(); + let { reorder: t, sort: r } = this.options, + A = !0 === this.multiple, + n = this.selected; + return void 0 === n + ? this.alert() + : (Array.isArray(n) && !1 !== t && !0 !== r && (n = i.reorder(n)), + (this.value = A ? n.map((e) => e.name) : n.name), + super.submit()); + } + set choices(e = []) { + (this.state._choices = this.state._choices || []), + (this.state.choices = e); + for (let t of e) + this.state._choices.some((e) => e.name === t.name) || + this.state._choices.push(t); + if (!this._initial && this.options.initial) { + this._initial = !0; + let e = this.initial; + if ('string' == typeof e || 'number' == typeof e) { + let t = this.find(e); + t && ((this.initial = t.index), this.focus(t, !0)); + } + } + } + get choices() { + return u(this, this.state.choices || []); + } + set visible(e) { + this.state.visible = e; + } + get visible() { + return (this.state.visible || this.choices).slice(0, this.limit); + } + set limit(e) { + this.state.limit = e; + } + get limit() { + let { state: e, options: t, choices: r } = this, + A = e.limit || this._limit || t.limit || r.length; + return Math.min(A, this.height); + } + set value(e) { + super.value = e; + } + get value() { + return 'string' != typeof super.value && + super.value === this.initial + ? this.input + : super.value; + } + set index(e) { + this.state.index = e; + } + get index() { + return Math.max(0, this.state ? this.state.index : 0); + } + get enabled() { + return this.filter(this.isEnabled.bind(this)); + } + get focused() { + let e = this.choices[this.index]; + return ( + e && + this.state.submitted && + !0 !== this.multiple && + (e.enabled = !0), + e + ); + } + get selectable() { + return this.choices.filter((e) => !this.isDisabled(e)); + } + get selected() { + return this.multiple ? this.enabled : this.focused; + } + }; + }, + 46614: (e, t, r) => { + 'use strict'; + const A = r(71447), + n = () => { + throw new Error( + 'expected prompt to have a custom authenticate method' + ); + }, + o = (e = n) => + class extends A { + constructor(e) { + super(e); + } + async submit() { + (this.value = await e.call(this, this.values, this.state)), + super.base.submit.call(this); + } + static create(e) { + return o(e); + } + }; + e.exports = o(); + }, + 82710: (e, t, r) => { + 'use strict'; + const A = r(58386), + { isPrimitive: n, hasColor: o } = r(10278); + e.exports = class extends A { + constructor(e) { + super(e), this.cursorHide(); + } + async initialize() { + let e = await this.resolve(this.initial, this.state); + (this.input = await this.cast(e)), await super.initialize(); + } + dispatch(e) { + return this.isValue(e) + ? ((this.input = e), this.submit()) + : this.alert(); + } + format(e) { + let { styles: t, state: r } = this; + return r.submitted ? t.success(e) : t.primary(e); + } + cast(e) { + return this.isTrue(e); + } + isTrue(e) { + return /^[ty1]/i.test(e); + } + isFalse(e) { + return /^[fn0]/i.test(e); + } + isValue(e) { + return n(e) && (this.isTrue(e) || this.isFalse(e)); + } + async hint() { + if ('pending' === this.state.status) { + let e = await this.element('hint'); + return o(e) ? e : this.styles.muted(e); + } + } + async render() { + let { input: e, size: t } = this.state, + r = await this.prefix(), + A = await this.separator(), + n = [r, await this.message(), this.styles.muted(this.default), A] + .filter(Boolean) + .join(' '); + this.state.prompt = n; + let o = await this.header(), + i = (this.value = this.cast(e)), + s = await this.format(i), + a = (await this.error()) || (await this.hint()), + c = await this.footer(); + a && !n.includes(a) && (s += ' ' + a), + (n += ' ' + s), + this.clear(t), + this.write([o, n, c].filter(Boolean).join('\n')), + this.restore(); + } + set value(e) { + super.value = e; + } + get value() { + return this.cast(super.value); + } + }; + }, + 13235: (e, t, r) => { + e.exports = { + ArrayPrompt: r(14723), + AuthPrompt: r(46614), + BooleanPrompt: r(82710), + NumberPrompt: r(64987), + StringPrompt: r(45853), + }; + }, + 64987: (e, t, r) => { + 'use strict'; + const A = r(45853); + e.exports = class extends A { + constructor(e = {}) { + super({ style: 'number', ...e }), + (this.min = this.isValue(e.min) ? this.toNumber(e.min) : -1 / 0), + (this.max = this.isValue(e.max) ? this.toNumber(e.max) : 1 / 0), + (this.delay = null != e.delay ? e.delay : 1e3), + (this.float = !1 !== e.float), + (this.round = !0 === e.round || !1 === e.float), + (this.major = e.major || 10), + (this.minor = e.minor || 1), + (this.initial = null != e.initial ? e.initial : ''), + (this.input = String(this.initial)), + (this.cursor = this.input.length), + this.cursorShow(); + } + append(e) { + return !/[-+.]/.test(e) || ('.' === e && this.input.includes('.')) + ? this.alert('invalid number') + : super.append(e); + } + number(e) { + return super.append(e); + } + next() { + return this.input && this.input !== this.initial + ? this.alert() + : this.isValue(this.initial) + ? ((this.input = this.initial), + (this.cursor = String(this.initial).length), + this.render()) + : this.alert(); + } + up(e) { + let t = e || this.minor, + r = this.toNumber(this.input); + return r > this.max + t + ? this.alert() + : ((this.input = '' + (r + t)), this.render()); + } + down(e) { + let t = e || this.minor, + r = this.toNumber(this.input); + return r < this.min - t + ? this.alert() + : ((this.input = '' + (r - t)), this.render()); + } + shiftDown() { + return this.down(this.major); + } + shiftUp() { + return this.up(this.major); + } + format(e = this.input) { + return 'function' == typeof this.options.format + ? this.options.format.call(this, e) + : this.styles.info(e); + } + toNumber(e = '') { + return this.float ? +e : Math.round(+e); + } + isValue(e) { + return /^[-+]?[0-9]+((\.)|(\.[0-9]+))?$/.test(e); + } + submit() { + let e = [this.input, this.initial].find((e) => this.isValue(e)); + return (this.value = this.toNumber(e || 0)), super.submit(); + } + }; + }, + 45853: (e, t, r) => { + 'use strict'; + const A = r(58386), + n = r(96496), + { isPrimitive: o } = r(10278); + e.exports = class extends A { + constructor(e) { + super(e), + (this.initial = o(this.initial) ? String(this.initial) : ''), + this.initial && this.cursorHide(), + (this.state.prevCursor = 0), + (this.state.clipboard = []); + } + async keypress(e, t = {}) { + let r = this.state.prevKeypress; + return ( + (this.state.prevKeypress = t), + !0 !== this.options.multiline || + 'return' !== t.name || + (r && 'return' === r.name) + ? super.keypress(e, t) + : this.append('\n', t) + ); + } + moveCursor(e) { + this.cursor += e; + } + reset() { + return ( + (this.input = this.value = ''), (this.cursor = 0), this.render() + ); + } + dispatch(e, t) { + if (!e || t.ctrl || t.code) return this.alert(); + this.append(e); + } + append(e) { + let { cursor: t, input: r } = this.state; + (this.input = ('' + r).slice(0, t) + e + ('' + r).slice(t)), + this.moveCursor(String(e).length), + this.render(); + } + insert(e) { + this.append(e); + } + delete() { + let { cursor: e, input: t } = this.state; + if (e <= 0) return this.alert(); + (this.input = ('' + t).slice(0, e - 1) + ('' + t).slice(e)), + this.moveCursor(-1), + this.render(); + } + deleteForward() { + let { cursor: e, input: t } = this.state; + if (void 0 === t[e]) return this.alert(); + (this.input = ('' + t).slice(0, e) + ('' + t).slice(e + 1)), + this.render(); + } + cutForward() { + let e = this.cursor; + if (this.input.length <= e) return this.alert(); + this.state.clipboard.push(this.input.slice(e)), + (this.input = this.input.slice(0, e)), + this.render(); + } + cutLeft() { + let e = this.cursor; + if (0 === e) return this.alert(); + let t = this.input.slice(0, e), + r = this.input.slice(e), + A = t.split(' '); + this.state.clipboard.push(A.pop()), + (this.input = A.join(' ')), + (this.cursor = this.input.length), + (this.input += r), + this.render(); + } + paste() { + if (!this.state.clipboard.length) return this.alert(); + this.insert(this.state.clipboard.pop()), this.render(); + } + toggleCursor() { + this.state.prevCursor + ? ((this.cursor = this.state.prevCursor), + (this.state.prevCursor = 0)) + : ((this.state.prevCursor = this.cursor), (this.cursor = 0)), + this.render(); + } + first() { + (this.cursor = 0), this.render(); + } + last() { + (this.cursor = this.input.length - 1), this.render(); + } + next() { + let e = null != this.initial ? String(this.initial) : ''; + if (!e || !e.startsWith(this.input)) return this.alert(); + (this.input = this.initial), + (this.cursor = this.initial.length), + this.render(); + } + prev() { + if (!this.input) return this.alert(); + this.reset(); + } + backward() { + return this.left(); + } + forward() { + return this.right(); + } + right() { + return this.cursor >= this.input.length + ? this.alert() + : (this.moveCursor(1), this.render()); + } + left() { + return this.cursor <= 0 + ? this.alert() + : (this.moveCursor(-1), this.render()); + } + isValue(e) { + return !!e; + } + async format(e = this.value) { + let t = await this.resolve(this.initial, this.state); + return this.state.submitted + ? this.styles.submitted(e || t) + : n(this, { input: e, initial: t, pos: this.cursor }); + } + async render() { + let e = this.state.size, + t = await this.prefix(), + r = await this.separator(), + A = [t, await this.message(), r].filter(Boolean).join(' '); + this.state.prompt = A; + let n = await this.header(), + o = await this.format(), + i = (await this.error()) || (await this.hint()), + s = await this.footer(); + i && !o.includes(i) && (o += ' ' + i), + (A += ' ' + o), + this.clear(e), + this.write([n, A, s].filter(Boolean).join('\n')), + this.restore(); + } + }; + }, + 10278: (e, t, r) => { + 'use strict'; + const A = Object.prototype.toString, + n = r(97991); + let o = !1, + i = []; + const s = { + yellow: 'blue', + cyan: 'red', + green: 'magenta', + black: 'white', + blue: 'yellow', + red: 'cyan', + magenta: 'green', + white: 'black', + }; + (t.longest = (e, t) => + e.reduce((e, r) => Math.max(e, t ? r[t].length : r.length), 0)), + (t.hasColor = (e) => !!e && n.hasColor(e)); + const a = (t.isObject = (e) => + null !== e && 'object' == typeof e && !Array.isArray(e)); + (t.nativeType = (e) => + A.call(e).slice(8, -1).toLowerCase().replace(/\s/g, '')), + (t.isAsyncFn = (e) => 'asyncfunction' === t.nativeType(e)), + (t.isPrimitive = (e) => + null != e && 'object' != typeof e && 'function' != typeof e), + (t.resolve = (e, t, ...r) => + 'function' == typeof t ? t.call(e, ...r) : t), + (t.scrollDown = (e = []) => [...e.slice(1), e[0]]), + (t.scrollUp = (e = []) => [e.pop(), ...e]), + (t.reorder = (e = []) => { + let t = e.slice(); + return ( + t.sort((e, t) => + e.index > t.index ? 1 : e.index < t.index ? -1 : 0 + ), + t + ); + }), + (t.swap = (e, t, r) => { + let A = e.length, + n = r === A ? 0 : r < 0 ? A - 1 : r, + o = e[t]; + (e[t] = e[n]), (e[n] = o); + }), + (t.width = (e, t = 80) => { + let r = e && e.columns ? e.columns : t; + return ( + e && + 'function' == typeof e.getWindowSize && + (r = e.getWindowSize()[0]), + 'win32' === process.platform ? r - 1 : r + ); + }), + (t.height = (e, t = 20) => { + let r = e && e.rows ? e.rows : t; + return ( + e && + 'function' == typeof e.getWindowSize && + (r = e.getWindowSize()[1]), + r + ); + }), + (t.wordWrap = (e, t = {}) => { + if (!e) return e; + 'number' == typeof t && (t = { width: t }); + let { indent: r = '', newline: A = '\n' + r, width: n = 80 } = t, + o = (A + r).match(/[^\S\n]/g) || []; + n -= o.length; + let i = `.{1,${n}}([\\s\\u200B]+|$)|[^\\s\\u200B]+?([\\s\\u200B]+|$)`, + s = e.trim(), + a = new RegExp(i, 'g'), + c = s.match(a) || []; + return ( + (c = c.map((e) => e.replace(/\n$/, ''))), + t.padEnd && (c = c.map((e) => e.padEnd(n, ' '))), + t.padStart && (c = c.map((e) => e.padStart(n, ' '))), + r + c.join(A) + ); + }), + (t.unmute = (e) => { + let t = e.stack.find((e) => n.keys.color.includes(e)); + return t + ? n[t] + : e.stack.find((e) => 'bg' === e.slice(2)) + ? n[t.slice(2)] + : (e) => e; + }), + (t.pascal = (e) => (e ? e[0].toUpperCase() + e.slice(1) : '')), + (t.inverse = (e) => { + if (!e || !e.stack) return e; + let r = e.stack.find((e) => n.keys.color.includes(e)); + if (r) { + let A = n['bg' + t.pascal(r)]; + return A ? A.black : e; + } + let A = e.stack.find((e) => 'bg' === e.slice(0, 2)); + return A ? n[A.slice(2).toLowerCase()] || e : n.none; + }), + (t.complement = (e) => { + if (!e || !e.stack) return e; + let r = e.stack.find((e) => n.keys.color.includes(e)), + A = e.stack.find((e) => 'bg' === e.slice(0, 2)); + if (r && !A) return n[s[r] || r]; + if (A) { + let r = A.slice(2).toLowerCase(), + o = s[r]; + return (o && n['bg' + t.pascal(o)]) || e; + } + return n.none; + }), + (t.meridiem = (e) => { + let t = e.getHours(), + r = e.getMinutes(), + A = t >= 12 ? 'pm' : 'am'; + return ( + (t %= 12), + (0 === t ? 12 : t) + ':' + (r < 10 ? '0' + r : r) + ' ' + A + ); + }), + (t.set = (e = {}, r = '', A) => + r.split('.').reduce((e, r, n, o) => { + let i = o.length - 1 > n ? e[r] || {} : A; + return !t.isObject(i) && n < o.length - 1 && (i = {}), (e[r] = i); + }, e)), + (t.get = (e = {}, t = '', r) => { + let A = + null == e[t] ? t.split('.').reduce((e, t) => e && e[t], e) : e[t]; + return null == A ? r : A; + }), + (t.mixin = (e, r) => { + if (!a(e)) return r; + if (!a(r)) return e; + for (let A of Object.keys(r)) { + let n = Object.getOwnPropertyDescriptor(r, A); + if (n.hasOwnProperty('value')) + if (e.hasOwnProperty(A) && a(n.value)) { + let o = Object.getOwnPropertyDescriptor(e, A); + a(o.value) + ? (e[A] = t.merge({}, e[A], r[A])) + : Reflect.defineProperty(e, A, n); + } else Reflect.defineProperty(e, A, n); + else Reflect.defineProperty(e, A, n); + } + return e; + }), + (t.merge = (...e) => { + let r = {}; + for (let A of e) t.mixin(r, A); + return r; + }), + (t.mixinEmitter = (e, r) => { + let A = r.constructor.prototype; + for (let n of Object.keys(A)) { + let o = A[n]; + 'function' == typeof o + ? t.define(e, n, o.bind(r)) + : t.define(e, n, o); + } + }), + (t.onExit = (e) => { + const t = (e, t) => { + o || + ((o = !0), + i.forEach((e) => e()), + !0 === e && process.exit(128 + t)); + }; + 0 === i.length && + (process.once('SIGTERM', t.bind(null, !0, 15)), + process.once('SIGINT', t.bind(null, !0, 2)), + process.once('exit', t)), + i.push(e); + }), + (t.define = (e, t, r) => { + Reflect.defineProperty(e, t, { value: r }); + }), + (t.defineExport = (e, t, r) => { + let A; + Reflect.defineProperty(e, t, { + enumerable: !0, + configurable: !0, + set(e) { + A = e; + }, + get: () => (A ? A() : r()), + }); + }); + }, + 19347: (e, t, r) => { + 'use strict'; + const A = r(80598), + n = r(58182), + o = r(67652), + i = r(81340), + s = r(43754), + a = r(16777); + async function c(e, t) { + l(e); + const r = g(e, n.default, t), + A = await Promise.all(r); + return a.array.flatten(A); + } + function g(e, t, r) { + const n = [].concat(e), + o = new s.default(r), + i = A.generate(n, o), + a = new t(o); + return i.map(a.read, a); + } + function l(e) { + if ( + ![] + .concat(e) + .every((e) => a.string.isString(e) && !a.string.isEmpty(e)) + ) + throw new TypeError( + 'Patterns must be a string (non empty) or an array of strings' + ); + } + !(function (e) { + (e.sync = function (e, t) { + l(e); + const r = g(e, i.default, t); + return a.array.flatten(r); + }), + (e.stream = function (e, t) { + l(e); + const r = g(e, o.default, t); + return a.stream.merge(r); + }), + (e.generateTasks = function (e, t) { + l(e); + const r = [].concat(e), + n = new s.default(t); + return A.generate(r, n); + }), + (e.isDynamicPattern = function (e, t) { + l(e); + const r = new s.default(t); + return a.pattern.isDynamicPattern(e, r); + }), + (e.escapePath = function (e) { + return l(e), a.path.escape(e); + }); + })(c || (c = {})), + (e.exports = c); + }, + 80598: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777); + function n(e, t, r) { + const A = s(e); + if ('.' in A) { + return [c('.', e, t, r)]; + } + return a(A, t, r); + } + function o(e) { + return A.pattern.getPositivePatterns(e); + } + function i(e, t) { + return A.pattern + .getNegativePatterns(e) + .concat(t) + .map(A.pattern.convertToPositivePattern); + } + function s(e) { + return e.reduce((e, t) => { + const r = A.pattern.getBaseDirectory(t); + return r in e ? e[r].push(t) : (e[r] = [t]), e; + }, {}); + } + function a(e, t, r) { + return Object.keys(e).map((A) => c(A, e[A], t, r)); + } + function c(e, t, r, n) { + return { + dynamic: n, + positive: t, + negative: r, + base: e, + patterns: [].concat(t, r.map(A.pattern.convertToNegativePattern)), + }; + } + (t.generate = function (e, t) { + const r = o(e), + s = i(e, t.ignore), + a = r.filter((e) => A.pattern.isStaticPattern(e, t)), + c = r.filter((e) => A.pattern.isDynamicPattern(e, t)), + g = n(a, s, !1), + l = n(c, s, !0); + return g.concat(l); + }), + (t.convertPatternsToTasks = n), + (t.getPositivePatterns = o), + (t.getNegativePatternsAsPositive = i), + (t.groupPatternsByBaseDirectory = s), + (t.convertPatternGroupsToTasks = a), + (t.convertPatternGroupToTask = c); + }, + 58182: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(82774), + n = r(40545); + class o extends n.default { + constructor() { + super(...arguments), (this._reader = new A.default(this._settings)); + } + read(e) { + const t = this._getRootDirectory(e), + r = this._getReaderOptions(e), + A = []; + return new Promise((n, o) => { + const i = this.api(t, e, r); + i.once('error', o), + i.on('data', (e) => A.push(r.transform(e))), + i.once('end', () => n(A)); + }); + } + api(e, t, r) { + return t.dynamic + ? this._reader.dynamic(e, r) + : this._reader.static(t.patterns, r); + } + } + t.default = o; + }, + 65989: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777), + n = r(42585); + t.default = class { + constructor(e, t) { + (this._settings = e), (this._micromatchOptions = t); + } + getFilter(e, t, r) { + const A = this._getMatcher(t), + n = this._getNegativePatternsRe(r); + return (t) => this._filter(e, t, A, n); + } + _getMatcher(e) { + return new n.default(e, this._settings, this._micromatchOptions); + } + _getNegativePatternsRe(e) { + const t = e.filter(A.pattern.isAffectDepthOfReadingPattern); + return A.pattern.convertPatternsToRe(t, this._micromatchOptions); + } + _filter(e, t, r, n) { + const o = this._getEntryLevel(e, t.path); + if (this._isSkippedByDeep(o)) return !1; + if (this._isSkippedSymbolicLink(t)) return !1; + const i = A.path.removeLeadingDotSegment(t.path); + return ( + !this._isSkippedByPositivePatterns(i, r) && + this._isSkippedByNegativePatterns(i, n) + ); + } + _isSkippedByDeep(e) { + return e >= this._settings.deep; + } + _isSkippedSymbolicLink(e) { + return ( + !this._settings.followSymbolicLinks && e.dirent.isSymbolicLink() + ); + } + _getEntryLevel(e, t) { + const r = e.split('/').length; + return t.split('/').length - ('' === e ? 0 : r); + } + _isSkippedByPositivePatterns(e, t) { + return !this._settings.baseNameMatch && !t.match(e); + } + _isSkippedByNegativePatterns(e, t) { + return !A.pattern.matchAny(e, t); + } + }; + }, + 37338: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777); + t.default = class { + constructor(e, t) { + (this._settings = e), + (this._micromatchOptions = t), + (this.index = new Map()); + } + getFilter(e, t) { + const r = A.pattern.convertPatternsToRe(e, this._micromatchOptions), + n = A.pattern.convertPatternsToRe(t, this._micromatchOptions); + return (e) => this._filter(e, r, n); + } + _filter(e, t, r) { + if (this._settings.unique) { + if (this._isDuplicateEntry(e)) return !1; + this._createIndexRecord(e); + } + if (this._onlyFileFilter(e) || this._onlyDirectoryFilter(e)) + return !1; + if (this._isSkippedByAbsoluteNegativePatterns(e, r)) return !1; + const A = this._settings.baseNameMatch ? e.name : e.path; + return ( + this._isMatchToPatterns(A, t) && + !this._isMatchToPatterns(e.path, r) + ); + } + _isDuplicateEntry(e) { + return this.index.has(e.path); + } + _createIndexRecord(e) { + this.index.set(e.path, void 0); + } + _onlyFileFilter(e) { + return this._settings.onlyFiles && !e.dirent.isFile(); + } + _onlyDirectoryFilter(e) { + return this._settings.onlyDirectories && !e.dirent.isDirectory(); + } + _isSkippedByAbsoluteNegativePatterns(e, t) { + if (!this._settings.absolute) return !1; + const r = A.path.makeAbsolute(this._settings.cwd, e.path); + return this._isMatchToPatterns(r, t); + } + _isMatchToPatterns(e, t) { + const r = A.path.removeLeadingDotSegment(e); + return A.pattern.matchAny(r, t); + } + }; + }, + 54345: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777); + t.default = class { + constructor(e) { + this._settings = e; + } + getFilter() { + return (e) => this._isNonFatalError(e); + } + _isNonFatalError(e) { + return ( + A.errno.isEnoentCodeError(e) || this._settings.suppressErrors + ); + } + }; + }, + 34789: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777); + t.default = class { + constructor(e, t, r) { + (this._patterns = e), + (this._settings = t), + (this._micromatchOptions = r), + (this._storage = []), + this._fillStorage(); + } + _fillStorage() { + const e = A.pattern.expandPatternsWithBraceExpansion( + this._patterns + ); + for (const t of e) { + const e = this._getPatternSegments(t), + r = this._splitSegmentsIntoSections(e); + this._storage.push({ + complete: r.length <= 1, + pattern: t, + segments: e, + sections: r, + }); + } + } + _getPatternSegments(e) { + return A.pattern + .getPatternParts(e, this._micromatchOptions) + .map((e) => + A.pattern.isDynamicPattern(e, this._settings) + ? { + dynamic: !0, + pattern: e, + patternRe: A.pattern.makeRe(e, this._micromatchOptions), + } + : { dynamic: !1, pattern: e } + ); + } + _splitSegmentsIntoSections(e) { + return A.array.splitWhen( + e, + (e) => e.dynamic && A.pattern.hasGlobStar(e.pattern) + ); + } + }; + }, + 42585: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(34789); + class n extends A.default { + match(e) { + const t = e.split('/'), + r = t.length, + A = this._storage.filter( + (e) => !e.complete || e.segments.length > r + ); + for (const e of A) { + const A = e.sections[0]; + if (!e.complete && r > A.length) return !0; + if ( + t.every((t, r) => { + const A = e.segments[r]; + return ( + !(!A.dynamic || !A.patternRe.test(t)) || + (!A.dynamic && A.pattern === t) + ); + }) + ) + return !0; + } + return !1; + } + } + t.default = n; + }, + 40545: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = r(65989), + o = r(37338), + i = r(54345), + s = r(77541); + t.default = class { + constructor(e) { + (this._settings = e), + (this.errorFilter = new i.default(this._settings)), + (this.entryFilter = new o.default( + this._settings, + this._getMicromatchOptions() + )), + (this.deepFilter = new n.default( + this._settings, + this._getMicromatchOptions() + )), + (this.entryTransformer = new s.default(this._settings)); + } + _getRootDirectory(e) { + return A.resolve(this._settings.cwd, e.base); + } + _getReaderOptions(e) { + const t = '.' === e.base ? '' : e.base; + return { + basePath: t, + pathSegmentSeparator: '/', + concurrency: this._settings.concurrency, + deepFilter: this.deepFilter.getFilter(t, e.positive, e.negative), + entryFilter: this.entryFilter.getFilter(e.positive, e.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: !0, + strictSlashes: !1, + }; + } + }; + }, + 67652: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(92413), + n = r(82774), + o = r(40545); + class i extends o.default { + constructor() { + super(...arguments), (this._reader = new n.default(this._settings)); + } + read(e) { + const t = this._getRootDirectory(e), + r = this._getReaderOptions(e), + n = this.api(t, e, r), + o = new A.Readable({ objectMode: !0, read: () => {} }); + return ( + n + .once('error', (e) => o.emit('error', e)) + .on('data', (e) => o.emit('data', r.transform(e))) + .once('end', () => o.emit('end')), + o.once('close', () => n.destroy()), + o + ); + } + api(e, t, r) { + return t.dynamic + ? this._reader.dynamic(e, r) + : this._reader.static(t.patterns, r); + } + } + t.default = i; + }, + 81340: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(29543), + n = r(40545); + class o extends n.default { + constructor() { + super(...arguments), (this._reader = new A.default(this._settings)); + } + read(e) { + const t = this._getRootDirectory(e), + r = this._getReaderOptions(e); + return this.api(t, e, r).map(r.transform); + } + api(e, t, r) { + return t.dynamic + ? this._reader.dynamic(e, r) + : this._reader.static(t.patterns, r); + } + } + t.default = o; + }, + 77541: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(16777); + t.default = class { + constructor(e) { + this._settings = e; + } + getTransformer() { + return (e) => this._transform(e); + } + _transform(e) { + let t = e.path; + return ( + this._settings.absolute && + ((t = A.path.makeAbsolute(this._settings.cwd, t)), + (t = A.path.unixify(t))), + this._settings.markDirectories && + e.dirent.isDirectory() && + (t += '/'), + this._settings.objectMode + ? Object.assign(Object.assign({}, e), { path: t }) + : t + ); + } + }; + }, + 99458: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = r(53403), + o = r(16777); + t.default = class { + constructor(e) { + (this._settings = e), + (this._fsStatSettings = new n.Settings({ + followSymbolicLink: this._settings.followSymbolicLinks, + fs: this._settings.fs, + throwErrorOnBrokenSymbolicLink: this._settings + .followSymbolicLinks, + })); + } + _getFullEntryPath(e) { + return A.resolve(this._settings.cwd, e); + } + _makeEntry(e, t) { + const r = { + name: t, + path: t, + dirent: o.fs.createDirentFromStats(t, e), + }; + return this._settings.stats && (r.stats = e), r; + } + _isFatalError(e) { + return ( + !o.errno.isEnoentCodeError(e) && !this._settings.suppressErrors + ); + } + }; + }, + 82774: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(92413), + n = r(53403), + o = r(72897), + i = r(99458); + class s extends i.default { + constructor() { + super(...arguments), + (this._walkStream = o.walkStream), + (this._stat = n.stat); + } + dynamic(e, t) { + return this._walkStream(e, t); + } + static(e, t) { + const r = e.map(this._getFullEntryPath, this), + n = new A.PassThrough({ objectMode: !0 }); + n._write = (A, o, i) => + this._getEntry(r[A], e[A], t) + .then((e) => { + null !== e && t.entryFilter(e) && n.push(e), + A === r.length - 1 && n.end(), + i(); + }) + .catch(i); + for (let e = 0; e < r.length; e++) n.write(e); + return n; + } + _getEntry(e, t, r) { + return this._getStat(e) + .then((e) => this._makeEntry(e, t)) + .catch((e) => { + if (r.errorFilter(e)) return null; + throw e; + }); + } + _getStat(e) { + return new Promise((t, r) => { + this._stat(e, this._fsStatSettings, (e, A) => + null === e ? t(A) : r(e) + ); + }); + } + } + t.default = s; + }, + 29543: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(53403), + n = r(72897), + o = r(99458); + class i extends o.default { + constructor() { + super(...arguments), + (this._walkSync = n.walkSync), + (this._statSync = A.statSync); + } + dynamic(e, t) { + return this._walkSync(e, t); + } + static(e, t) { + const r = []; + for (const A of e) { + const e = this._getFullEntryPath(A), + n = this._getEntry(e, A, t); + null !== n && t.entryFilter(n) && r.push(n); + } + return r; + } + _getEntry(e, t, r) { + try { + const r = this._getStat(e); + return this._makeEntry(r, t); + } catch (e) { + if (r.errorFilter(e)) return null; + throw e; + } + } + _getStat(e) { + return this._statSync(e, this._fsStatSettings); + } + } + t.default = i; + }, + 43754: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(35747), + n = r(12087).cpus().length; + t.DEFAULT_FILE_SYSTEM_ADAPTER = { + lstat: A.lstat, + lstatSync: A.lstatSync, + stat: A.stat, + statSync: A.statSync, + readdir: A.readdir, + readdirSync: A.readdirSync, + }; + t.default = class { + constructor(e = {}) { + (this._options = e), + (this.absolute = this._getValue(this._options.absolute, !1)), + (this.baseNameMatch = this._getValue( + this._options.baseNameMatch, + !1 + )), + (this.braceExpansion = this._getValue( + this._options.braceExpansion, + !0 + )), + (this.caseSensitiveMatch = this._getValue( + this._options.caseSensitiveMatch, + !0 + )), + (this.concurrency = this._getValue(this._options.concurrency, n)), + (this.cwd = this._getValue(this._options.cwd, process.cwd())), + (this.deep = this._getValue(this._options.deep, 1 / 0)), + (this.dot = this._getValue(this._options.dot, !1)), + (this.extglob = this._getValue(this._options.extglob, !0)), + (this.followSymbolicLinks = this._getValue( + this._options.followSymbolicLinks, + !0 + )), + (this.fs = this._getFileSystemMethods(this._options.fs)), + (this.globstar = this._getValue(this._options.globstar, !0)), + (this.ignore = this._getValue(this._options.ignore, [])), + (this.markDirectories = this._getValue( + this._options.markDirectories, + !1 + )), + (this.objectMode = this._getValue(this._options.objectMode, !1)), + (this.onlyDirectories = this._getValue( + this._options.onlyDirectories, + !1 + )), + (this.onlyFiles = this._getValue(this._options.onlyFiles, !0)), + (this.stats = this._getValue(this._options.stats, !1)), + (this.suppressErrors = this._getValue( + this._options.suppressErrors, + !1 + )), + (this.throwErrorOnBrokenSymbolicLink = this._getValue( + this._options.throwErrorOnBrokenSymbolicLink, + !1 + )), + (this.unique = this._getValue(this._options.unique, !0)), + this.onlyDirectories && (this.onlyFiles = !1), + this.stats && (this.objectMode = !0); + } + _getValue(e, t) { + return void 0 === e ? t : e; + } + _getFileSystemMethods(e = {}) { + return Object.assign( + Object.assign({}, t.DEFAULT_FILE_SYSTEM_ADAPTER), + e + ); + } + }; + }, + 60919: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.flatten = function (e) { + return e.reduce((e, t) => [].concat(e, t), []); + }), + (t.splitWhen = function (e, t) { + const r = [[]]; + let A = 0; + for (const n of e) t(n) ? (A++, (r[A] = [])) : r[A].push(n); + return r; + }); + }, + 35525: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.isEnoentCodeError = function (e) { + return 'ENOENT' === e.code; + }); + }, + 62524: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + class r { + constructor(e, t) { + (this.name = e), + (this.isBlockDevice = t.isBlockDevice.bind(t)), + (this.isCharacterDevice = t.isCharacterDevice.bind(t)), + (this.isDirectory = t.isDirectory.bind(t)), + (this.isFIFO = t.isFIFO.bind(t)), + (this.isFile = t.isFile.bind(t)), + (this.isSocket = t.isSocket.bind(t)), + (this.isSymbolicLink = t.isSymbolicLink.bind(t)); + } + } + t.createDirentFromStats = function (e, t) { + return new r(e, t); + }; + }, + 16777: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(60919); + t.array = A; + const n = r(35525); + t.errno = n; + const o = r(62524); + t.fs = o; + const i = r(71462); + t.path = i; + const s = r(14659); + t.pattern = s; + const a = r(2042); + t.stream = a; + const c = r(10217); + t.string = c; + }, + 71462: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g; + (t.unixify = function (e) { + return e.replace(/\\/g, '/'); + }), + (t.makeAbsolute = function (e, t) { + return A.resolve(e, t); + }), + (t.escape = function (e) { + return e.replace(n, '\\$2'); + }), + (t.removeLeadingDotSegment = function (e) { + if ('.' === e.charAt(0)) { + const t = e.charAt(1); + if ('/' === t || '\\' === t) return e.slice(2); + } + return e; + }); + }, + 14659: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(85622), + n = r(97098), + o = r(2401), + i = r(54722), + s = /[*?]|^!/, + a = /\[.*]/, + c = /(?:^|[^!*+?@])\(.*\|.*\)/, + g = /[!*+?@]\(.*\)/, + l = /{.*(?:,|\.\.).*}/; + function u(e, t = {}) { + return !h(e, t); + } + function h(e, t = {}) { + return ( + !(!1 !== t.caseSensitiveMatch && !e.includes('\\')) || + !!(s.test(e) || a.test(e) || c.test(e)) || + !(!1 === t.extglob || !g.test(e)) || + !(!1 === t.braceExpansion || !l.test(e)) + ); + } + function p(e) { + return e.startsWith('!') && '(' !== e[1]; + } + function d(e) { + return !p(e); + } + function C(e) { + return e.endsWith('/**'); + } + function f(e) { + return o.braces(e, { expand: !0, nodupes: !0 }); + } + function I(e, t) { + return o.makeRe(e, t); + } + (t.isStaticPattern = u), + (t.isDynamicPattern = h), + (t.convertToPositivePattern = function (e) { + return p(e) ? e.slice(1) : e; + }), + (t.convertToNegativePattern = function (e) { + return '!' + e; + }), + (t.isNegativePattern = p), + (t.isPositivePattern = d), + (t.getNegativePatterns = function (e) { + return e.filter(p); + }), + (t.getPositivePatterns = function (e) { + return e.filter(d); + }), + (t.getBaseDirectory = function (e) { + return n(e, { flipBackslashes: !1 }); + }), + (t.hasGlobStar = function (e) { + return e.includes('**'); + }), + (t.endsWithSlashGlobStar = C), + (t.isAffectDepthOfReadingPattern = function (e) { + const t = A.basename(e); + return C(e) || u(t); + }), + (t.expandPatternsWithBraceExpansion = function (e) { + return e.reduce((e, t) => e.concat(f(t)), []); + }), + (t.expandBraceExpansion = f), + (t.getPatternParts = function (e, t) { + const r = i.scan( + e, + Object.assign(Object.assign({}, t), { parts: !0 }) + ); + return 0 === r.parts.length ? [e] : r.parts; + }), + (t.makeRe = I), + (t.convertPatternsToRe = function (e, t) { + return e.map((e) => I(e, t)); + }), + (t.matchAny = function (e, t) { + return t.some((t) => t.test(e)); + }); + }, + 2042: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(55598); + function n(e) { + e.forEach((e) => e.emit('close')); + } + t.merge = function (e) { + const t = A(e); + return ( + e.forEach((e) => { + e.once('error', (e) => t.emit('error', e)); + }), + t.once('close', () => n(e)), + t.once('end', () => n(e)), + t + ); + }; + }, + 10217: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.isString = function (e) { + return 'string' == typeof e; + }), + (t.isEmpty = function (e) { + return '' === e; + }); + }, + 98360: (e, t, r) => { + 'use strict'; + var A = r(2383); + function n() {} + function o() { + (this.value = null), + (this.callback = n), + (this.next = null), + (this.release = n), + (this.context = null); + var e = this; + this.worked = function (t, r) { + var A = e.callback; + (e.value = null), + (e.callback = n), + A.call(e.context, t, r), + e.release(e); + }; + } + e.exports = function (e, t, r) { + 'function' == typeof e && ((r = t), (t = e), (e = null)); + var i = A(o), + s = null, + a = null, + c = 0, + g = { + push: function (r, A) { + var o = i.get(); + (o.context = e), + (o.release = l), + (o.value = r), + (o.callback = A || n), + c === g.concurrency || g.paused + ? a + ? ((a.next = o), (a = o)) + : ((s = o), (a = o), g.saturated()) + : (c++, t.call(e, o.value, o.worked)); + }, + drain: n, + saturated: n, + pause: function () { + g.paused = !0; + }, + paused: !1, + concurrency: r, + running: function () { + return c; + }, + resume: function () { + if (!g.paused) return; + g.paused = !1; + for (var e = 0; e < g.concurrency; e++) c++, l(); + }, + idle: function () { + return 0 === c && 0 === g.length(); + }, + length: function () { + var e = s, + t = 0; + for (; e; ) (e = e.next), t++; + return t; + }, + unshift: function (r, A) { + var o = i.get(); + (o.context = e), + (o.release = l), + (o.value = r), + (o.callback = A || n), + c === g.concurrency || g.paused + ? s + ? ((o.next = s), (s = o)) + : ((s = o), (a = o), g.saturated()) + : (c++, t.call(e, o.value, o.worked)); + }, + empty: n, + kill: function () { + (s = null), (a = null), (g.drain = n); + }, + killAndDrain: function () { + (s = null), (a = null), g.drain(), (g.drain = n); + }, + }; + return g; + function l(r) { + r && i.release(r); + var A = s; + A + ? g.paused + ? c-- + : (a === s && (a = null), + (s = A.next), + (A.next = null), + t.call(e, A.value, A.worked), + null === a && g.empty()) + : 0 == --c && g.drain(); + } + }; + }, + 19184: (e, t, r) => { + 'use strict'; + class A { + constructor(e, t, r) { + (this.__specs = e || {}), + Object.keys(this.__specs).forEach((e) => { + if ('string' == typeof this.__specs[e]) { + const t = this.__specs[e], + r = this.__specs[t]; + if (!r) + throw new Error( + `Alias refers to invalid key: ${t} -> ${e}` + ); + { + const A = r.aliases || []; + A.push(e, t), + (r.aliases = [...new Set(A)]), + (this.__specs[e] = r); + } + } + }), + (this.__opts = t || {}), + (this.__providers = s( + r.filter((e) => null != e && 'object' == typeof e) + )), + (this.__isFiggyPudding = !0); + } + get(e) { + return n(this, e, !0); + } + get [Symbol.toStringTag]() { + return 'FiggyPudding'; + } + forEach(e, t = this) { + for (let [r, A] of this.entries()) e.call(t, A, r, this); + } + toJSON() { + const e = {}; + return ( + this.forEach((t, r) => { + e[r] = t; + }), + e + ); + } + *entries(e) { + for (let e of Object.keys(this.__specs)) yield [e, this.get(e)]; + const t = e || this.__opts.other; + if (t) { + const e = new Set(); + for (let r of this.__providers) { + const A = r.entries ? r.entries(t) : a(r); + for (let [r, n] of A) + t(r) && !e.has(r) && (e.add(r), yield [r, n]); + } + } + } + *[Symbol.iterator]() { + for (let [e, t] of this.entries()) yield [e, t]; + } + *keys() { + for (let [e] of this.entries()) yield e; + } + *values() { + for (let [, e] of this.entries()) yield e; + } + concat(...e) { + return new Proxy( + new A(this.__specs, this.__opts, s(this.__providers).concat(e)), + i + ); + } + } + try { + const e = r(31669); + A.prototype[e.inspect.custom] = function (t, r) { + return this[Symbol.toStringTag] + ' ' + e.inspect(this.toJSON(), r); + }; + } catch (e) {} + function n(e, t, r) { + let A = e.__specs[t]; + if (!r || A || (e.__opts.other && e.__opts.other(t))) { + let r; + A || (A = {}); + for (let n of e.__providers) { + if ( + ((r = o(t, n)), void 0 === r && A.aliases && A.aliases.length) + ) + for (let e of A.aliases) + if (e !== t && ((r = o(e, n)), void 0 !== r)) break; + if (void 0 !== r) break; + } + return void 0 === r && void 0 !== A.default + ? 'function' == typeof A.default + ? A.default(e) + : A.default + : r; + } + !(function (e) { + throw Object.assign( + new Error('invalid config key requested: ' + e), + { code: 'EBADKEY' } + ); + })(t); + } + function o(e, t) { + let r; + return ( + (r = t.__isFiggyPudding + ? n(t, e, !1) + : 'function' == typeof t.get + ? t.get(e) + : t[e]), + r + ); + } + const i = { + has: (e, t) => t in e.__specs && void 0 !== n(e, t, !1), + ownKeys: (e) => Object.keys(e.__specs), + get: (e, t) => + 'symbol' == typeof t || '__' === t.slice(0, 2) || t in A.prototype + ? e[t] + : e.get(t), + set(e, t, r) { + if ('symbol' == typeof t || '__' === t.slice(0, 2)) + return (e[t] = r), !0; + throw new Error( + 'figgyPudding options cannot be modified. Use .concat() instead.' + ); + }, + deleteProperty() { + throw new Error( + 'figgyPudding options cannot be deleted. Use .concat() and shadow them instead.' + ); + }, + }; + function s(e) { + const t = []; + return e.forEach((e) => t.unshift(e)), t; + } + function a(e) { + return Object.keys(e).map((t) => [t, e[t]]); + } + e.exports = function (e, t) { + return function (...r) { + return new Proxy(new A(e, t, r), i); + }; + }; + }, + 52169: (e, t, r) => { + 'use strict'; + /*! + * fill-range + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Licensed under the MIT License. + */ const A = r(31669), + n = r(84615), + o = (e) => null !== e && 'object' == typeof e && !Array.isArray(e), + i = (e) => 'number' == typeof e || ('string' == typeof e && '' !== e), + s = (e) => Number.isInteger(+e), + a = (e) => { + let t = '' + e, + r = -1; + if (('-' === t[0] && (t = t.slice(1)), '0' === t)) return !1; + for (; '0' === t[++r]; ); + return r > 0; + }, + c = (e, t, r) => { + if (t > 0) { + let r = '-' === e[0] ? '-' : ''; + r && (e = e.slice(1)), (e = r + e.padStart(r ? t - 1 : t, '0')); + } + return !1 === r ? String(e) : e; + }, + g = (e, t) => { + let r = '-' === e[0] ? '-' : ''; + for (r && ((e = e.slice(1)), t--); e.length < t; ) e = '0' + e; + return r ? '-' + e : e; + }, + l = (e, t, r, A) => { + if (r) return n(e, t, { wrap: !1, ...A }); + let o = String.fromCharCode(e); + return e === t ? o : `[${o}-${String.fromCharCode(t)}]`; + }, + u = (e, t, r) => { + if (Array.isArray(e)) { + let t = !0 === r.wrap, + A = r.capture ? '' : '?:'; + return t ? `(${A}${e.join('|')})` : e.join('|'); + } + return n(e, t, r); + }, + h = (...e) => + new RangeError('Invalid range arguments: ' + A.inspect(...e)), + p = (e, t, r) => { + if (!0 === r.strictRanges) throw h([e, t]); + return []; + }, + d = (e, t, r = 1, A = {}) => { + let n = Number(e), + o = Number(t); + if (!Number.isInteger(n) || !Number.isInteger(o)) { + if (!0 === A.strictRanges) throw h([e, t]); + return []; + } + 0 === n && (n = 0), 0 === o && (o = 0); + let i = n > o, + s = String(e), + p = String(t), + d = String(r); + r = Math.max(Math.abs(r), 1); + let C = a(s) || a(p) || a(d), + f = C ? Math.max(s.length, p.length, d.length) : 0, + I = + !1 === C && + !1 === + ((e, t, r) => + 'string' == typeof e || + 'string' == typeof t || + !0 === r.stringify)(e, t, A), + E = + A.transform || + ((e) => (t) => (!0 === e ? Number(t) : String(t)))(I); + if (A.toRegex && 1 === r) return l(g(e, f), g(t, f), !0, A); + let B = { negatives: [], positives: [] }, + y = [], + m = 0; + for (; i ? n >= o : n <= o; ) + !0 === A.toRegex && r > 1 + ? B[(w = n) < 0 ? 'negatives' : 'positives'].push(Math.abs(w)) + : y.push(c(E(n, m), f, I)), + (n = i ? n - r : n + r), + m++; + var w; + return !0 === A.toRegex + ? r > 1 + ? ((e, t) => { + e.negatives.sort((e, t) => (e < t ? -1 : e > t ? 1 : 0)), + e.positives.sort((e, t) => (e < t ? -1 : e > t ? 1 : 0)); + let r, + A = t.capture ? '' : '?:', + n = '', + o = ''; + return ( + e.positives.length && (n = e.positives.join('|')), + e.negatives.length && + (o = `-(${A}${e.negatives.join('|')})`), + (r = n && o ? `${n}|${o}` : n || o), + t.wrap ? `(${A}${r})` : r + ); + })(B, A) + : u(y, null, { wrap: !1, ...A }) + : y; + }, + C = (e, t, r, A = {}) => { + if (null == t && i(e)) return [e]; + if (!i(e) || !i(t)) return p(e, t, A); + if ('function' == typeof r) return C(e, t, 1, { transform: r }); + if (o(r)) return C(e, t, 0, r); + let n = { ...A }; + return ( + !0 === n.capture && (n.wrap = !0), + (r = r || n.step || 1), + s(r) + ? s(e) && s(t) + ? d(e, t, r, n) + : ((e, t, r = 1, A = {}) => { + if ((!s(e) && e.length > 1) || (!s(t) && t.length > 1)) + return p(e, t, A); + let n = A.transform || ((e) => String.fromCharCode(e)), + o = ('' + e).charCodeAt(0), + i = ('' + t).charCodeAt(0), + a = o > i, + c = Math.min(o, i), + g = Math.max(o, i); + if (A.toRegex && 1 === r) return l(c, g, !1, A); + let h = [], + d = 0; + for (; a ? o >= i : o <= i; ) + h.push(n(o, d)), (o = a ? o - r : o + r), d++; + return !0 === A.toRegex + ? u(h, null, { wrap: !1, options: A }) + : h; + })(e, t, Math.max(Math.abs(r), 1), n) + : null == r || o(r) + ? C(e, t, 1, r) + : ((e, t) => { + if (!0 === t.strictRanges) + throw new TypeError( + `Expected step "${e}" to be a number` + ); + return []; + })(r, n) + ); + }; + e.exports = C; + }, + 50683: (e) => { + e.exports = function (e) { + return [...e].reduce((e, [t, r]) => ((e[t] = r), e), {}); + }; + }, + 13302: (e, t, r) => { + e.exports = r(35747).constants || r(27619); + }, + 72137: (e, t, r) => { + 'use strict'; + const { PassThrough: A } = r(92413); + e.exports = (e) => { + e = { ...e }; + const { array: t } = e; + let { encoding: r } = e; + const n = 'buffer' === r; + let o = !1; + t ? (o = !(r || n)) : (r = r || 'utf8'), n && (r = null); + const i = new A({ objectMode: o }); + r && i.setEncoding(r); + let s = 0; + const a = []; + return ( + i.on('data', (e) => { + a.push(e), o ? (s = a.length) : (s += e.length); + }), + (i.getBufferedValue = () => + t ? a : n ? Buffer.concat(a, s) : a.join('')), + (i.getBufferedLength = () => s), + i + ); + }; + }, + 58764: (e, t, r) => { + 'use strict'; + const A = r(50372), + n = r(72137); + class o extends Error { + constructor() { + super('maxBuffer exceeded'), (this.name = 'MaxBufferError'); + } + } + async function i(e, t) { + if (!e) return Promise.reject(new Error('Expected a stream')); + t = { maxBuffer: 1 / 0, ...t }; + const { maxBuffer: r } = t; + let i; + return ( + await new Promise((s, a) => { + const c = (e) => { + e && (e.bufferedData = i.getBufferedValue()), a(e); + }; + (i = A(e, n(t), (e) => { + e ? c(e) : s(); + })), + i.on('data', () => { + i.getBufferedLength() > r && c(new o()); + }); + }), + i.getBufferedValue() + ); + } + (e.exports = i), + (e.exports.default = i), + (e.exports.buffer = (e, t) => i(e, { ...t, encoding: 'buffer' })), + (e.exports.array = (e, t) => i(e, { ...t, array: !0 })), + (e.exports.MaxBufferError = o); + }, + 97098: (e, t, r) => { + 'use strict'; + var A = r(18193), + n = r(85622).posix.dirname, + o = 'win32' === r(12087).platform(), + i = /\\/g, + s = /[\{\[].*[\/]*.*[\}\]]$/, + a = /(^|[^\\])([\{\[]|\([^\)]+$)/, + c = /\\([\*\?\|\[\]\(\)\{\}])/g; + e.exports = function (e, t) { + Object.assign({ flipBackslashes: !0 }, t).flipBackslashes && + o && + e.indexOf('/') < 0 && + (e = e.replace(i, '/')), + s.test(e) && (e += '/'), + (e += 'a'); + do { + e = n(e); + } while (A(e) || a.test(e)); + return e.replace(c, '$1'); + }; + }, + 90734: (e, t, r) => { + 'use strict'; + const { promisify: A } = r(31669), + n = r(35747), + o = r(85622), + i = r(19347), + s = r(46458), + a = r(17234), + c = [ + '**/node_modules/**', + '**/flow-typed/**', + '**/coverage/**', + '**/.git', + ], + g = A(n.readFile), + l = (e, t) => { + const r = a(o.relative(t.cwd, o.dirname(t.fileName))); + return e + .split(/\r?\n/) + .filter(Boolean) + .filter((e) => !e.startsWith('#')) + .map( + ((e) => (t) => + t.startsWith('!') + ? '!' + o.posix.join(e, t.slice(1)) + : o.posix.join(e, t))(r) + ); + }, + u = (e) => + e.reduce( + (e, t) => ( + e.add(l(t.content, { cwd: t.cwd, fileName: t.filePath })), e + ), + s() + ), + h = (e, t) => (r) => + e.ignores( + a( + o.relative( + t, + ((e, t) => { + if (((e = a(e)), o.isAbsolute(t))) { + if (t.startsWith(e)) return t; + throw new Error(`Path ${t} is not in cwd ${e}`); + } + return o.join(e, t); + })(t, r) + ) + ) + ), + p = ({ ignore: e = [], cwd: t = a(process.cwd()) } = {}) => ({ + ignore: e, + cwd: t, + }); + (e.exports = async (e) => { + e = p(e); + const t = await i('**/.gitignore', { + ignore: c.concat(e.ignore), + cwd: e.cwd, + }), + r = await Promise.all( + t.map((t) => + (async (e, t) => { + const r = o.join(t, e); + return { cwd: t, filePath: r, content: await g(r, 'utf8') }; + })(t, e.cwd) + ) + ), + A = u(r); + return h(A, e.cwd); + }), + (e.exports.sync = (e) => { + e = p(e); + const t = i + .sync('**/.gitignore', { + ignore: c.concat(e.ignore), + cwd: e.cwd, + }) + .map((t) => + ((e, t) => { + const r = o.join(t, e); + return { + cwd: t, + filePath: r, + content: n.readFileSync(r, 'utf8'), + }; + })(t, e.cwd) + ), + r = u(t); + return h(r, e.cwd); + }); + }, + 58592: (e, t, r) => { + 'use strict'; + const A = r(35747), + n = r(39920), + o = r(55598), + i = r(19347), + s = r(66241), + a = r(90734), + { FilterStream: c, UniqueStream: g } = r(66160), + l = () => !1, + u = (e) => '!' === e[0], + h = (e, t) => { + ((e) => { + if (!e.every((e) => 'string' == typeof e)) + throw new TypeError( + 'Patterns must be a string or an array of strings' + ); + })((e = n([].concat(e)))), + ((e = {}) => { + if (!e.cwd) return; + let t; + try { + t = A.statSync(e.cwd); + } catch (e) { + return; + } + if (!t.isDirectory()) + throw new Error( + 'The `cwd` option must be a path to a directory' + ); + })(t); + const r = []; + t = { ignore: [], expandDirectories: !0, ...t }; + for (const [A, n] of e.entries()) { + if (u(n)) continue; + const o = e + .slice(A) + .filter(u) + .map((e) => e.slice(1)), + i = { ...t, ignore: t.ignore.concat(o) }; + r.push({ pattern: n, options: i }); + } + return r; + }, + p = (e, t) => + e.options.expandDirectories + ? ((e, t) => { + let r = {}; + return ( + e.options.cwd && (r.cwd = e.options.cwd), + Array.isArray(e.options.expandDirectories) + ? (r = { ...r, files: e.options.expandDirectories }) + : 'object' == typeof e.options.expandDirectories && + (r = { ...r, ...e.options.expandDirectories }), + t(e.pattern, r) + ); + })(e, t) + : [e.pattern], + d = (e) => + e && e.gitignore ? a.sync({ cwd: e.cwd, ignore: e.ignore }) : l, + C = (e) => (t) => { + const { options: r } = e; + return ( + r.ignore && + Array.isArray(r.ignore) && + r.expandDirectories && + (r.ignore = s.sync(r.ignore)), + { pattern: t, options: r } + ); + }; + (e.exports = async (e, t) => { + const r = h(e, t), + [o, c] = await Promise.all([ + (async () => + t && t.gitignore ? a({ cwd: t.cwd, ignore: t.ignore }) : l)(), + (async () => { + const e = await Promise.all( + r.map(async (e) => { + const t = await p(e, s); + return Promise.all(t.map(C(e))); + }) + ); + return n(...e); + })(), + ]), + g = await Promise.all(c.map((e) => i(e.pattern, e.options))); + return n(...g).filter((e) => { + return !o(((t = e), t.stats instanceof A.Stats ? t.path : t)); + var t; + }); + }), + (e.exports.sync = (e, t) => { + const r = h(e, t).reduce((e, t) => { + const r = p(t, s.sync).map(C(t)); + return e.concat(r); + }, []), + A = d(t); + return r + .reduce((e, t) => n(e, i.sync(t.pattern, t.options)), []) + .filter((e) => !A(e)); + }), + (e.exports.stream = (e, t) => { + const r = h(e, t).reduce((e, t) => { + const r = p(t, s.sync).map(C(t)); + return e.concat(r); + }, []), + A = d(t), + n = new c((e) => !A(e)), + a = new g(); + return o(r.map((e) => i.stream(e.pattern, e.options))) + .pipe(n) + .pipe(a); + }), + (e.exports.generateGlobTasks = h), + (e.exports.hasMagic = (e, t) => + [].concat(e).some((e) => i.isDynamicPattern(e, t))), + (e.exports.gitignore = a); + }, + 66160: (e, t, r) => { + 'use strict'; + const { Transform: A } = r(92413); + class n extends A { + constructor() { + super({ objectMode: !0 }); + } + } + e.exports = { + FilterStream: class extends n { + constructor(e) { + super(), (this._filter = e); + } + _transform(e, t, r) { + this._filter(e) && this.push(e), r(); + } + }, + UniqueStream: class extends n { + constructor() { + super(), (this._pushed = new Set()); + } + _transform(e, t, r) { + this._pushed.has(e) || (this.push(e), this._pushed.add(e)), r(); + } + }, + }; + }, + 93576: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(14756); + t.default = function (e, ...t) { + const r = (async () => { + if (e instanceof A.RequestError) + try { + for (const r of t) if (r) for (const t of r) e = await t(e); + } catch (t) { + e = t; + } + throw e; + })(), + n = () => r; + return (r.json = n), (r.text = n), (r.buffer = n), (r.on = n), r; + }; + }, + 81588: function (e, t, r) { + 'use strict'; + var A = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, A) { + void 0 === A && (A = r), + Object.defineProperty(e, A, { + enumerable: !0, + get: function () { + return t[r]; + }, + }); + } + : function (e, t, r, A) { + void 0 === A && (A = r), (e[A] = t[r]); + }), + n = + (this && this.__exportStar) || + function (e, t) { + for (var r in e) + 'default' === r || + Object.prototype.hasOwnProperty.call(t, r) || + A(t, e, r); + }; + Object.defineProperty(t, '__esModule', { value: !0 }); + const o = r(28614), + i = r(7966), + s = r(59351), + a = r(14756), + c = r(54718), + g = r(9048), + l = r(51743), + u = r(57854), + h = r(38206), + p = [ + 'request', + 'response', + 'redirect', + 'uploadProgress', + 'downloadProgress', + ]; + (t.default = function e(t) { + let r, A; + const n = new o.EventEmitter(), + d = new s((o, s, C) => { + const f = (I) => { + const E = new g.default(void 0, t); + (E.retryCount = I), + (E._noPipe = !0), + C(() => E.destroy()), + (C.shouldReject = !1), + C(() => s(new a.CancelError(E))), + (r = E), + E.once('response', async (t) => { + var r; + if (((t.retryCount = I), t.request.aborted)) return; + let n; + try { + (n = await u.default(E)), (t.rawBody = n); + } catch (e) { + return; + } + if (E._isAboutToError) return; + const i = (null !== (r = t.headers['content-encoding']) && + void 0 !== r + ? r + : '' + ).toLowerCase(), + s = ['gzip', 'deflate', 'br'].includes(i), + { options: l } = E; + if (s && !l.decompress) t.body = n; + else + try { + t.body = c.default( + t, + l.responseType, + l.parseJson, + l.encoding + ); + } catch (e) { + if (((t.body = n.toString()), h.isResponseOk(t))) + return void E._beforeError(e); + } + try { + for (const [r, A] of l.hooks.afterResponse.entries()) + t = await A(t, async (t) => { + const A = g.default.normalizeArguments( + void 0, + { + ...t, + retry: { calculateDelay: () => 0 }, + throwHttpErrors: !1, + resolveBodyOnly: !1, + }, + l + ); + A.hooks.afterResponse = A.hooks.afterResponse.slice( + 0, + r + ); + for (const e of A.hooks.beforeRetry) await e(A); + const n = e(A); + return ( + C(() => { + n.catch(() => {}), n.cancel(); + }), + n + ); + }); + } catch (e) { + return void E._beforeError( + new a.RequestError(e.message, e, E) + ); + } + h.isResponseOk(t) + ? ((A = t), o(E.options.resolveBodyOnly ? t.body : t)) + : E._beforeError(new a.HTTPError(t)); + }); + const B = (e) => { + if (d.isCanceled) return; + const { options: t } = E; + if (e instanceof a.HTTPError && !t.throwHttpErrors) { + const { response: t } = e; + o(E.options.resolveBodyOnly ? t.body : t); + } else s(e); + }; + E.once('error', B), + E.once('retry', (e, t) => { + var r; + i.default.nodeStream( + null === (r = t.request) || void 0 === r + ? void 0 + : r.options.body + ) + ? B(t) + : f(e); + }), + l.default(E, n, p); + }; + f(0); + }); + d.on = (e, t) => (n.on(e, t), d); + const C = (e) => { + const t = (async () => { + await d; + const { options: t } = A.request; + return c.default(A, e, t.parseJson, t.encoding); + })(); + return ( + Object.defineProperties(t, Object.getOwnPropertyDescriptors(d)), t + ); + }; + return ( + (d.json = () => { + const { headers: e } = r.options; + return ( + r.writableFinished || + void 0 !== e.accept || + (e.accept = 'application/json'), + C('json') + ); + }), + (d.buffer = () => C('buffer')), + (d.text = () => C('text')), + d + ); + }), + n(r(14756), t); + }, + 41514: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(7966); + t.default = (e, t) => { + if (A.default.null_(e.encoding)) + throw new TypeError( + 'To get a Buffer, set `options.responseType` to `buffer` instead' + ); + A.assert.any([A.default.string, A.default.undefined], e.encoding), + A.assert.any( + [A.default.boolean, A.default.undefined], + e.resolveBodyOnly + ), + A.assert.any( + [A.default.boolean, A.default.undefined], + e.methodRewriting + ), + A.assert.any([A.default.boolean, A.default.undefined], e.isStream), + A.assert.any( + [A.default.string, A.default.undefined], + e.responseType + ), + void 0 === e.responseType && (e.responseType = 'text'); + const { retry: r } = e; + if ( + ((e.retry = t + ? { ...t.retry } + : { + calculateDelay: (e) => e.computedValue, + limit: 0, + methods: [], + statusCodes: [], + errorCodes: [], + maxRetryAfter: void 0, + }), + A.default.object(r) + ? ((e.retry = { ...e.retry, ...r }), + (e.retry.methods = [ + ...new Set(e.retry.methods.map((e) => e.toUpperCase())), + ]), + (e.retry.statusCodes = [...new Set(e.retry.statusCodes)]), + (e.retry.errorCodes = [...new Set(e.retry.errorCodes)])) + : A.default.number(r) && (e.retry.limit = r), + A.default.undefined(e.retry.maxRetryAfter) && + (e.retry.maxRetryAfter = Math.min( + ...[e.timeout.request, e.timeout.connect].filter( + A.default.number + ) + )), + A.default.object(e.pagination)) + ) { + t && (e.pagination = { ...t.pagination, ...e.pagination }); + const { pagination: r } = e; + if (!A.default.function_(r.transform)) + throw new Error( + '`options.pagination.transform` must be implemented' + ); + if (!A.default.function_(r.shouldContinue)) + throw new Error( + '`options.pagination.shouldContinue` must be implemented' + ); + if (!A.default.function_(r.filter)) + throw new TypeError( + '`options.pagination.filter` must be implemented' + ); + if (!A.default.function_(r.paginate)) + throw new Error( + '`options.pagination.paginate` must be implemented' + ); + } + return ( + 'json' === e.responseType && + void 0 === e.headers.accept && + (e.headers.accept = 'application/json'), + e + ); + }; + }, + 54718: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(14756); + t.default = (e, t, r, n) => { + const { rawBody: o } = e; + try { + if ('text' === t) return o.toString(n); + if ('json' === t) return 0 === o.length ? '' : r(o.toString()); + if ('buffer' === t) return o; + throw new A.ParseError( + { message: `Unknown body type '${t}'`, name: 'Error' }, + e + ); + } catch (t) { + throw new A.ParseError(t, e); + } + }; + }, + 14756: function (e, t, r) { + 'use strict'; + var A = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, A) { + void 0 === A && (A = r), + Object.defineProperty(e, A, { + enumerable: !0, + get: function () { + return t[r]; + }, + }); + } + : function (e, t, r, A) { + void 0 === A && (A = r), (e[A] = t[r]); + }), + n = + (this && this.__exportStar) || + function (e, t) { + for (var r in e) + 'default' === r || + Object.prototype.hasOwnProperty.call(t, r) || + A(t, e, r); + }; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.CancelError = t.ParseError = void 0); + const o = r(9048); + class i extends o.RequestError { + constructor(e, t) { + const { options: r } = t.request; + super(`${e.message} in "${r.url.toString()}"`, e, t.request), + (this.name = 'ParseError'); + } + } + t.ParseError = i; + class s extends o.RequestError { + constructor(e) { + super('Promise was canceled', {}, e), (this.name = 'CancelError'); + } + get isCanceled() { + return !0; + } + } + (t.CancelError = s), n(r(9048), t); + }, + 53843: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.retryAfterStatusCodes = void 0), + (t.retryAfterStatusCodes = new Set([413, 429, 503])); + t.default = ({ + attemptCount: e, + retryOptions: t, + error: r, + retryAfter: A, + }) => { + if (e > t.limit) return 0; + const n = t.methods.includes(r.options.method), + o = t.errorCodes.includes(r.code), + i = r.response && t.statusCodes.includes(r.response.statusCode); + if (!n || (!o && !i)) return 0; + if (r.response) { + if (A) + return void 0 === t.maxRetryAfter || A > t.maxRetryAfter ? 0 : A; + if (413 === r.response.statusCode) return 0; + } + return 2 ** (e - 1) * 1e3 + 100 * Math.random(); + }; + }, + 9048: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.UnsupportedProtocolError = t.ReadError = t.TimeoutError = t.UploadError = t.CacheError = t.HTTPError = t.MaxRedirectsError = t.RequestError = t.setNonEnumerableProperties = t.knownHookEvents = t.withoutBody = t.kIsNormalizedAlready = void 0); + const A = r(31669), + n = r(92413), + o = r(35747), + i = r(78835), + s = r(98605), + a = r(98605), + c = r(57211), + g = r(98298), + l = r(30093), + u = r(11200), + h = r(93868), + p = r(92353), + d = r(55737), + C = r(7966), + f = r(78586), + I = r(2920), + E = r(51743), + B = r(44947), + y = r(50116), + m = r(82524), + w = r(85551), + Q = r(57854), + D = r(11338), + b = r(38206), + v = r(54595), + S = r(41514), + k = r(53843), + N = new l.default(), + F = Symbol('request'), + K = Symbol('response'), + M = Symbol('responseSize'), + R = Symbol('downloadedSize'), + x = Symbol('bodySize'), + L = Symbol('uploadedSize'), + P = Symbol('serverResponsesPiped'), + O = Symbol('unproxyEvents'), + U = Symbol('isFromCache'), + T = Symbol('cancelTimeouts'), + j = Symbol('startedReading'), + Y = Symbol('stopReading'), + G = Symbol('triggerRead'), + H = Symbol('body'), + J = Symbol('jobs'), + q = Symbol('originalResponse'), + z = Symbol('retryTimeout'); + t.kIsNormalizedAlready = Symbol('isNormalizedAlready'); + const W = C.default.string(process.versions.brotli); + (t.withoutBody = new Set(['GET', 'HEAD'])), + (t.knownHookEvents = [ + 'init', + 'beforeRequest', + 'beforeRedirect', + 'beforeError', + 'beforeRetry', + 'afterResponse', + ]); + const V = new w.default(), + X = new Set([300, 301, 302, 303, 304, 307, 308]), + _ = ['context', 'body', 'json', 'form']; + t.setNonEnumerableProperties = (e, t) => { + const r = {}; + for (const t of e) + if (t) + for (const e of _) + e in t && + (r[e] = { + writable: !0, + configurable: !0, + enumerable: !1, + value: t[e], + }); + Object.defineProperties(t, r); + }; + class Z extends Error { + constructor(e, t, r) { + var A; + if ( + (super(e), + Error.captureStackTrace(this, this.constructor), + (this.name = 'RequestError'), + (this.code = t.code), + r instanceof se + ? (Object.defineProperty(this, 'request', { + enumerable: !1, + value: r, + }), + Object.defineProperty(this, 'response', { + enumerable: !1, + value: r[K], + }), + Object.defineProperty(this, 'options', { + enumerable: !1, + value: r.options, + })) + : Object.defineProperty(this, 'options', { + enumerable: !1, + value: r, + }), + (this.timings = + null === (A = this.request) || void 0 === A + ? void 0 + : A.timings), + !C.default.undefined(t.stack)) + ) { + const e = this.stack.indexOf(this.message) + this.message.length, + r = this.stack.slice(e).split('\n').reverse(), + A = t.stack + .slice(t.stack.indexOf(t.message) + t.message.length) + .split('\n') + .reverse(); + for (; 0 !== A.length && A[0] === r[0]; ) r.shift(); + this.stack = `${this.stack.slice(0, e)}${r + .reverse() + .join('\n')}${A.reverse().join('\n')}`; + } + } + } + t.RequestError = Z; + class $ extends Z { + constructor(e) { + super( + `Redirected ${e.options.maxRedirects} times. Aborting.`, + {}, + e + ), + (this.name = 'MaxRedirectsError'); + } + } + t.MaxRedirectsError = $; + class ee extends Z { + constructor(e) { + super( + `Response code ${e.statusCode} (${e.statusMessage})`, + {}, + e.request + ), + (this.name = 'HTTPError'); + } + } + t.HTTPError = ee; + class te extends Z { + constructor(e, t) { + super(e.message, e, t), (this.name = 'CacheError'); + } + } + t.CacheError = te; + class re extends Z { + constructor(e, t) { + super(e.message, e, t), (this.name = 'UploadError'); + } + } + t.UploadError = re; + class Ae extends Z { + constructor(e, t, r) { + super(e.message, e, r), + (this.name = 'TimeoutError'), + (this.event = e.event), + (this.timings = t); + } + } + t.TimeoutError = Ae; + class ne extends Z { + constructor(e, t) { + super(e.message, e, t), (this.name = 'ReadError'); + } + } + t.ReadError = ne; + class oe extends Z { + constructor(e) { + super(`Unsupported protocol "${e.url.protocol}"`, {}, e), + (this.name = 'UnsupportedProtocolError'); + } + } + t.UnsupportedProtocolError = oe; + const ie = [ + 'socket', + 'connect', + 'continue', + 'information', + 'upgrade', + 'timeout', + ]; + class se extends n.Duplex { + constructor(e, r = {}, A) { + super({ autoDestroy: !1, highWaterMark: 0 }), + (this[R] = 0), + (this[L] = 0), + (this.requestInitialized = !1), + (this[P] = new Set()), + (this.redirects = []), + (this[Y] = !1), + (this[G] = !1), + (this[J] = []), + (this.retryCount = 0), + (this._progressCallbacks = []); + const n = () => this._unlockWrite(), + i = () => this._lockWrite(); + this.on('pipe', (e) => { + e.prependListener('data', n), + e.on('data', i), + e.prependListener('end', n), + e.on('end', i); + }), + this.on('unpipe', (e) => { + e.off('data', n), + e.off('data', i), + e.off('end', n), + e.off('end', i); + }), + this.on('pipe', (e) => { + e instanceof a.IncomingMessage && + (this.options.headers = { + ...e.headers, + ...this.options.headers, + }); + }); + const { json: s, body: c, form: g } = r; + if ( + ((s || c || g) && this._lockWrite(), t.kIsNormalizedAlready in r) + ) + this.options = r; + else + try { + this.options = this.constructor.normalizeArguments(e, r, A); + } catch (e) { + return ( + C.default.nodeStream(r.body) && r.body.destroy(), + void this.destroy(e) + ); + } + (async () => { + var e; + try { + this.options.body instanceof o.ReadStream && + (await (async (e) => + new Promise((t, r) => { + const A = (e) => { + r(e); + }; + e.pending || t(), + e.once('error', A), + e.once('ready', () => { + e.off('error', A), t(); + }); + }))(this.options.body)); + const { url: t } = this.options; + if (!t) throw new TypeError('Missing `url` property'); + if ( + ((this.requestUrl = t.toString()), + decodeURI(this.requestUrl), + await this._finalizeBody(), + await this._makeRequest(), + this.destroyed) + ) + return void ( + null === (e = this[F]) || + void 0 === e || + e.destroy() + ); + for (const e of this[J]) e(); + (this[J].length = 0), (this.requestInitialized = !0); + } catch (e) { + if (e instanceof Z) return void this._beforeError(e); + this.destroyed || this.destroy(e); + } + })(); + } + static normalizeArguments(e, r, n) { + var o, s, a, c, g; + const l = r; + if (C.default.object(e) && !C.default.urlInstance(e)) + r = { ...n, ...e, ...r }; + else { + if (e && r && void 0 !== r.url) + throw new TypeError( + 'The `url` option is mutually exclusive with the `input` argument' + ); + (r = { ...n, ...r }), + void 0 !== e && (r.url = e), + C.default.urlInstance(r.url) && + (r.url = new i.URL(r.url.toString())); + } + if ( + (!1 === r.cache && (r.cache = void 0), + !1 === r.dnsCache && (r.dnsCache = void 0), + C.assert.any([C.default.string, C.default.undefined], r.method), + C.assert.any([C.default.object, C.default.undefined], r.headers), + C.assert.any( + [C.default.string, C.default.urlInstance, C.default.undefined], + r.prefixUrl + ), + C.assert.any( + [C.default.object, C.default.undefined], + r.cookieJar + ), + C.assert.any( + [C.default.object, C.default.string, C.default.undefined], + r.searchParams + ), + C.assert.any( + [C.default.object, C.default.string, C.default.undefined], + r.cache + ), + C.assert.any( + [C.default.object, C.default.number, C.default.undefined], + r.timeout + ), + C.assert.any([C.default.object, C.default.undefined], r.context), + C.assert.any([C.default.object, C.default.undefined], r.hooks), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.decompress + ), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.ignoreInvalidCookies + ), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.followRedirect + ), + C.assert.any( + [C.default.number, C.default.undefined], + r.maxRedirects + ), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.throwHttpErrors + ), + C.assert.any([C.default.boolean, C.default.undefined], r.http2), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.allowGetBody + ), + C.assert.any( + [C.default.string, C.default.undefined], + r.localAddress + ), + C.assert.any( + [D.isDnsLookupIpVersion, C.default.undefined], + r.dnsLookupIpVersion + ), + C.assert.any([C.default.object, C.default.undefined], r.https), + C.assert.any( + [C.default.boolean, C.default.undefined], + r.rejectUnauthorized + ), + r.https && + (C.assert.any( + [C.default.boolean, C.default.undefined], + r.https.rejectUnauthorized + ), + C.assert.any( + [C.default.function_, C.default.undefined], + r.https.checkServerIdentity + ), + C.assert.any( + [ + C.default.string, + C.default.object, + C.default.array, + C.default.undefined, + ], + r.https.certificateAuthority + ), + C.assert.any( + [ + C.default.string, + C.default.object, + C.default.array, + C.default.undefined, + ], + r.https.key + ), + C.assert.any( + [ + C.default.string, + C.default.object, + C.default.array, + C.default.undefined, + ], + r.https.certificate + ), + C.assert.any( + [C.default.string, C.default.undefined], + r.https.passphrase + ), + C.assert.any( + [ + C.default.string, + C.default.buffer, + C.default.array, + C.default.undefined, + ], + r.https.pfx + )), + C.assert.any( + [C.default.object, C.default.undefined], + r.cacheOptions + ), + C.default.string(r.method) + ? (r.method = r.method.toUpperCase()) + : (r.method = 'GET'), + r.headers === (null == n ? void 0 : n.headers) + ? (r.headers = { ...r.headers }) + : (r.headers = d({ + ...(null == n ? void 0 : n.headers), + ...r.headers, + })), + 'slashes' in r) + ) + throw new TypeError( + 'The legacy `url.Url` has been deprecated. Use `URL` instead.' + ); + if ('auth' in r) + throw new TypeError( + 'Parameter `auth` is deprecated. Use `username` / `password` instead.' + ); + if ( + 'searchParams' in r && + r.searchParams && + r.searchParams !== (null == n ? void 0 : n.searchParams) + ) { + let e; + if ( + C.default.string(r.searchParams) || + r.searchParams instanceof i.URLSearchParams + ) + e = new i.URLSearchParams(r.searchParams); + else { + !(function (e) { + for (const t in e) { + const r = e[t]; + if ( + !( + C.default.string(r) || + C.default.number(r) || + C.default.boolean(r) || + C.default.null_(r) || + C.default.undefined(r) + ) + ) + throw new TypeError( + `The \`searchParams\` value '${String( + r + )}' must be a string, number, boolean or null` + ); + } + })(r.searchParams), + (e = new i.URLSearchParams()); + for (const t in r.searchParams) { + const A = r.searchParams[t]; + null === A ? e.append(t, '') : void 0 !== A && e.append(t, A); + } + } + null === (o = null == n ? void 0 : n.searchParams) || + void 0 === o || + o.forEach((t, r) => { + e.has(r) || e.append(r, t); + }), + (r.searchParams = e); + } + if ( + ((r.username = + null !== (s = r.username) && void 0 !== s ? s : ''), + (r.password = null !== (a = r.password) && void 0 !== a ? a : ''), + C.default.undefined(r.prefixUrl) + ? (r.prefixUrl = + null !== (c = null == n ? void 0 : n.prefixUrl) && + void 0 !== c + ? c + : '') + : ((r.prefixUrl = r.prefixUrl.toString()), + '' === r.prefixUrl || + r.prefixUrl.endsWith('/') || + (r.prefixUrl += '/')), + C.default.string(r.url)) + ) { + if (r.url.startsWith('/')) + throw new Error( + '`input` must not start with a slash when using `prefixUrl`' + ); + r.url = m.default(r.prefixUrl + r.url, r); + } else + ((C.default.undefined(r.url) && '' !== r.prefixUrl) || + r.protocol) && + (r.url = m.default(r.prefixUrl, r)); + if (r.url) { + 'port' in r && delete r.port; + let { prefixUrl: e } = r; + Object.defineProperty(r, 'prefixUrl', { + set: (t) => { + const A = r.url; + if (!A.href.startsWith(t)) + throw new Error( + `Cannot change \`prefixUrl\` from ${e} to ${t}: ${A.href}` + ); + (r.url = new i.URL(t + A.href.slice(e.length))), (e = t); + }, + get: () => e, + }); + let { protocol: t } = r.url; + if ( + ('unix:' === t && + ((t = 'http:'), + (r.url = new i.URL( + `http://unix${r.url.pathname}${r.url.search}` + ))), + r.searchParams && (r.url.search = r.searchParams.toString()), + 'http:' !== t && 'https:' !== t) + ) + throw new oe(r); + '' === r.username + ? (r.username = r.url.username) + : (r.url.username = r.username), + '' === r.password + ? (r.password = r.url.password) + : (r.url.password = r.password); + } + const { cookieJar: h } = r; + if (h) { + let { setCookie: e, getCookieString: t } = h; + C.assert.function_(e), + C.assert.function_(t), + 4 === e.length && + 0 === t.length && + ((e = A.promisify(e.bind(r.cookieJar))), + (t = A.promisify(t.bind(r.cookieJar))), + (r.cookieJar = { setCookie: e, getCookieString: t })); + } + const { cache: p } = r; + if ( + (p && + (V.has(p) || + V.set( + p, + new u((e, t) => { + const r = e[F](e, t); + return ( + C.default.promise(r) && + (r.once = (e, t) => { + if ('error' === e) r.catch(t); + else { + if ('abort' !== e) + throw new Error( + 'Unknown HTTP2 promise event: ' + e + ); + (async () => { + try { + (await r).once('abort', t); + } catch (e) {} + })(); + } + return r; + }), + r + ); + }, p) + )), + (r.cacheOptions = { ...r.cacheOptions }), + !0 === r.dnsCache) + ) + r.dnsCache = N; + else if (!C.default.undefined(r.dnsCache) && !r.dnsCache.lookup) + throw new TypeError( + 'Parameter `dnsCache` must be a CacheableLookup instance or a boolean, got ' + + C.default(r.dnsCache) + ); + C.default.number(r.timeout) + ? (r.timeout = { request: r.timeout }) + : n && r.timeout !== n.timeout + ? (r.timeout = { ...n.timeout, ...r.timeout }) + : (r.timeout = { ...r.timeout }), + r.context || (r.context = {}); + const f = r.hooks === (null == n ? void 0 : n.hooks); + r.hooks = { ...r.hooks }; + for (const e of t.knownHookEvents) + if (e in r.hooks) { + if (!C.default.array(r.hooks[e])) + throw new TypeError( + `Parameter \`${e}\` must be an Array, got ${C.default( + r.hooks[e] + )}` + ); + r.hooks[e] = [...r.hooks[e]]; + } else r.hooks[e] = []; + if (n && !f) + for (const e of t.knownHookEvents) { + 0 !== n.hooks[e].length && + (r.hooks[e] = [...n.hooks[e], ...r.hooks[e]]); + } + if ( + ('family' in r && + v.default( + '"options.family" was never documented, please use "options.dnsLookupIpVersion"' + ), + (null == n ? void 0 : n.https) && + (r.https = { ...n.https, ...r.https }), + 'rejectUnauthorized' in r && + v.default( + '"options.rejectUnauthorized" is now deprecated, please use "options.https.rejectUnauthorized"' + ), + 'checkServerIdentity' in r && + v.default( + '"options.checkServerIdentity" was never documented, please use "options.https.checkServerIdentity"' + ), + 'ca' in r && + v.default( + '"options.ca" was never documented, please use "options.https.certificateAuthority"' + ), + 'key' in r && + v.default( + '"options.key" was never documented, please use "options.https.key"' + ), + 'cert' in r && + v.default( + '"options.cert" was never documented, please use "options.https.certificate"' + ), + 'passphrase' in r && + v.default( + '"options.passphrase" was never documented, please use "options.https.passphrase"' + ), + 'pfx' in r && + v.default( + '"options.pfx" was never documented, please use "options.https.pfx"' + ), + 'followRedirects' in r) + ) + throw new TypeError( + 'The `followRedirects` option does not exist. Use `followRedirect` instead.' + ); + if (r.agent) + for (const e in r.agent) + if ('http' !== e && 'https' !== e && 'http2' !== e) + throw new TypeError( + `Expected the \`options.agent\` properties to be \`http\`, \`https\` or \`http2\`, got \`${e}\`` + ); + return ( + (r.maxRedirects = + null !== (g = r.maxRedirects) && void 0 !== g ? g : 0), + t.setNonEnumerableProperties([n, l], r), + S.default(r, n) + ); + } + _lockWrite() { + const e = () => { + throw new TypeError('The payload has been already provided'); + }; + (this.write = e), (this.end = e); + } + _unlockWrite() { + (this.write = super.write), (this.end = super.end); + } + async _finalizeBody() { + const { options: e } = this, + { headers: r } = e, + A = !C.default.undefined(e.form), + o = !C.default.undefined(e.json), + s = !C.default.undefined(e.body), + a = A || o || s, + c = + t.withoutBody.has(e.method) && + !('GET' === e.method && e.allowGetBody); + if (((this._cannotHaveBody = c), a)) { + if (c) + throw new TypeError( + `The \`${e.method}\` method cannot be used with a body` + ); + if ([s, A, o].filter((e) => e).length > 1) + throw new TypeError( + 'The `body`, `json` and `form` options are mutually exclusive' + ); + if ( + s && + !(e.body instanceof n.Readable) && + !C.default.string(e.body) && + !C.default.buffer(e.body) && + !I.default(e.body) + ) + throw new TypeError( + 'The `body` option must be a stream.Readable, string or Buffer' + ); + if (A && !C.default.object(e.form)) + throw new TypeError('The `form` option must be an Object'); + { + const t = !C.default.string(r['content-type']); + s + ? (I.default(e.body) && + t && + (r['content-type'] = + 'multipart/form-data; boundary=' + + e.body.getBoundary()), + (this[H] = e.body)) + : A + ? (t && + (r['content-type'] = 'application/x-www-form-urlencoded'), + (this[H] = new i.URLSearchParams(e.form).toString())) + : (t && (r['content-type'] = 'application/json'), + (this[H] = e.stringifyJson(e.json))); + const n = await f.default(this[H], e.headers); + C.default.undefined(r['content-length']) && + C.default.undefined(r['transfer-encoding']) && + (c || + C.default.undefined(n) || + (r['content-length'] = String(n))); + } + } else c ? this._lockWrite() : this._unlockWrite(); + this[x] = Number(r['content-length']) || void 0; + } + async _onResponseBase(e) { + const { options: t } = this, + { url: r } = t; + (this[q] = e), t.decompress && (e = h(e)); + const A = e.statusCode, + n = e; + (n.statusMessage = n.statusMessage + ? n.statusMessage + : s.STATUS_CODES[A]), + (n.url = t.url.toString()), + (n.requestUrl = this.requestUrl), + (n.redirectUrls = this.redirects), + (n.request = this), + (n.isFromCache = e.fromCache || !1), + (n.ip = this.ip), + (n.retryCount = this.retryCount), + (this[U] = n.isFromCache), + (this[M] = Number(e.headers['content-length']) || void 0), + (this[K] = e), + e.once('end', () => { + (this[M] = this[R]), + this.emit('downloadProgress', this.downloadProgress); + }), + e.once('error', (t) => { + e.destroy(), this._beforeError(new ne(t, this)); + }), + e.once('aborted', () => { + this._beforeError( + new ne( + { + name: 'Error', + message: 'The server aborted pending request', + code: 'ECONNRESET', + }, + this + ) + ); + }), + this.emit('downloadProgress', this.downloadProgress); + const o = e.headers['set-cookie']; + if (C.default.object(t.cookieJar) && o) { + let e = o.map(async (e) => + t.cookieJar.setCookie(e, r.toString()) + ); + t.ignoreInvalidCookies && + (e = e.map(async (e) => e.catch(() => {}))); + try { + await Promise.all(e); + } catch (e) { + return void this._beforeError(e); + } + } + if (t.followRedirect && e.headers.location && X.has(A)) { + e.resume(), this[F] && (this[T](), delete this[F], this[O]()); + if ( + ((!(303 === A && 'GET' !== t.method && 'HEAD' !== t.method) && + t.methodRewriting) || + ((t.method = 'GET'), + 'body' in t && delete t.body, + 'json' in t && delete t.json, + 'form' in t && delete t.form, + (this[H] = void 0), + delete t.headers['content-length']), + this.redirects.length >= t.maxRedirects) + ) + return void this._beforeError(new $(this)); + try { + const A = Buffer.from(e.headers.location, 'binary').toString(), + o = new i.URL(A, r), + s = o.toString(); + decodeURI(s), + o.hostname !== r.hostname || o.port !== r.port + ? ('host' in t.headers && delete t.headers.host, + 'cookie' in t.headers && delete t.headers.cookie, + 'authorization' in t.headers && + delete t.headers.authorization, + (t.username || t.password) && + ((t.username = ''), (t.password = ''))) + : ((o.username = t.username), (o.password = t.password)), + this.redirects.push(s), + (t.url = o); + for (const e of t.hooks.beforeRedirect) await e(t, n); + this.emit('redirect', n, t), await this._makeRequest(); + } catch (e) { + return void this._beforeError(e); + } + } else if (t.isStream && t.throwHttpErrors && !b.isResponseOk(n)) + this._beforeError(new ee(n)); + else { + e.on('readable', () => { + this[G] && this._read(); + }), + this.on('resume', () => { + e.resume(); + }), + this.on('pause', () => { + e.pause(); + }), + e.once('end', () => { + this.push(null); + }), + this.emit('response', e); + for (const r of this[P]) + if (!r.headersSent) { + for (const A in e.headers) { + const n = !t.decompress || 'content-encoding' !== A, + o = e.headers[A]; + n && r.setHeader(A, o); + } + r.statusCode = A; + } + } + } + async _onResponse(e) { + try { + await this._onResponseBase(e); + } catch (e) { + this._beforeError(e); + } + } + _onRequest(e) { + const { options: t } = this, + { timeout: r, url: A } = t; + g.default(e), (this[T] = B.default(e, r, A)); + const n = t.cache ? 'cacheableResponse' : 'response'; + e.once(n, (e) => { + this._onResponse(e); + }), + e.once('error', (t) => { + var r; + e.destroy(), + null === (r = e.res) || + void 0 === r || + r.removeAllListeners('end'), + (t = + t instanceof B.TimeoutError + ? new Ae(t, this.timings, this) + : new Z(t.message, t, this)), + this._beforeError(t); + }), + (this[O] = E.default(e, this, ie)), + (this[F] = e), + this.emit('uploadProgress', this.uploadProgress); + const o = this[H], + i = 0 === this.redirects.length ? this : e; + C.default.nodeStream(o) + ? (o.pipe(i), + o.once('error', (e) => { + this._beforeError(new re(e, this)); + })) + : (this._unlockWrite(), + C.default.undefined(o) + ? (this._cannotHaveBody || this._noPipe) && + (i.end(), this._lockWrite()) + : (this._writeRequest(o, void 0, () => {}), + i.end(), + this._lockWrite())), + this.emit('request', e); + } + async _createCacheableRequest(e, t) { + return new Promise((r, A) => { + let n; + Object.assign(t, y.default(e)), delete t.url; + const o = V.get(t.cache)(t, async (e) => { + (e._readableState.autoDestroy = !1), + n && (await n).emit('cacheableResponse', e), + r(e); + }); + (t.url = e), + o.once('error', A), + o.once('request', async (e) => { + (n = e), r(n); + }); + }); + } + async _makeRequest() { + var e, t, r, A, n; + const { options: o } = this, + { headers: i } = o; + for (const e in i) + if (C.default.undefined(i[e])) delete i[e]; + else if (C.default.null_(i[e])) + throw new TypeError( + `Use \`undefined\` instead of \`null\` to delete the \`${e}\` header` + ); + if ( + (o.decompress && + C.default.undefined(i['accept-encoding']) && + (i['accept-encoding'] = W + ? 'gzip, deflate, br' + : 'gzip, deflate'), + o.cookieJar) + ) { + const e = await o.cookieJar.getCookieString(o.url.toString()); + C.default.nonEmptyString(e) && (o.headers.cookie = e); + } + for (const e of o.hooks.beforeRequest) { + const t = await e(o); + if (!C.default.undefined(t)) { + o.request = () => t; + break; + } + } + o.body && this[H] !== o.body && (this[H] = o.body); + const { agent: a, request: g, timeout: l, url: h } = o; + if ( + (o.dnsCache && !('lookup' in o) && (o.lookup = o.dnsCache.lookup), + 'unix' === h.hostname) + ) { + const e = /(?.+?):(?.+)/.exec( + `${h.pathname}${h.search}` + ); + if (null == e ? void 0 : e.groups) { + const { socketPath: t, path: r } = e.groups; + Object.assign(o, { socketPath: t, path: r, host: '' }); + } + } + const d = 'https:' === h.protocol; + let f; + f = o.http2 ? p.auto : d ? c.request : s.request; + const I = null !== (e = o.request) && void 0 !== e ? e : f, + E = o.cache ? this._createCacheableRequest : I; + a && !o.http2 && (o.agent = a[d ? 'https' : 'http']), + (o[F] = I), + delete o.request, + delete o.timeout; + const B = o; + if ( + ((B.shared = + null === (t = o.cacheOptions) || void 0 === t + ? void 0 + : t.shared), + (B.cacheHeuristic = + null === (r = o.cacheOptions) || void 0 === r + ? void 0 + : r.cacheHeuristic), + (B.immutableMinTimeToLive = + null === (A = o.cacheOptions) || void 0 === A + ? void 0 + : A.immutableMinTimeToLive), + (B.ignoreCargoCult = + null === (n = o.cacheOptions) || void 0 === n + ? void 0 + : n.ignoreCargoCult), + void 0 !== o.dnsLookupIpVersion) + ) + try { + B.family = D.dnsLookupIpVersionToFamily(o.dnsLookupIpVersion); + } catch (e) { + throw new Error('Invalid `dnsLookupIpVersion` option value'); + } + o.https && + ('rejectUnauthorized' in o.https && + (B.rejectUnauthorized = o.https.rejectUnauthorized), + o.https.checkServerIdentity && + (B.checkServerIdentity = o.https.checkServerIdentity), + o.https.certificateAuthority && + (B.ca = o.https.certificateAuthority), + o.https.certificate && (B.cert = o.https.certificate), + o.https.key && (B.key = o.https.key), + o.https.passphrase && (B.passphrase = o.https.passphrase), + o.https.pfx && (B.pfx = o.https.pfx)); + try { + let e = await E(h, B); + C.default.undefined(e) && (e = f(h, B)), + (o.request = g), + (o.timeout = l), + (o.agent = a), + o.https && + ('rejectUnauthorized' in o.https && + delete B.rejectUnauthorized, + o.https.checkServerIdentity && delete B.checkServerIdentity, + o.https.certificateAuthority && delete B.ca, + o.https.certificate && delete B.cert, + o.https.key && delete B.key, + o.https.passphrase && delete B.passphrase, + o.https.pfx && delete B.pfx), + (y = e), + C.default.object(y) && !('statusCode' in y) + ? this._onRequest(e) + : this.writable + ? (this.once('finish', () => { + this._onResponse(e); + }), + this._unlockWrite(), + this.end(), + this._lockWrite()) + : this._onResponse(e); + } catch (e) { + if (e instanceof u.CacheError) throw new te(e, this); + throw new Z(e.message, e, this); + } + var y; + } + async _error(e) { + try { + for (const t of this.options.hooks.beforeError) e = await t(e); + } catch (t) { + e = new Z(t.message, t, this); + } + this.destroy(e); + } + _beforeError(e) { + if (this[Y]) return; + const { options: t } = this, + r = this.retryCount + 1; + (this[Y] = !0), e instanceof Z || (e = new Z(e.message, e, this)); + const A = e, + { response: n } = A; + (async () => { + if (n && !n.body) { + n.setEncoding(this._readableState.encoding); + try { + (n.rawBody = await Q.default(n)), + (n.body = n.rawBody.toString()); + } catch (e) {} + } + if (0 !== this.listenerCount('retry')) { + let o; + try { + let e; + n && + 'retry-after' in n.headers && + ((e = Number(n.headers['retry-after'])), + Number.isNaN(e) + ? ((e = + Date.parse(n.headers['retry-after']) - Date.now()), + e <= 0 && (e = 1)) + : (e *= 1e3)), + (o = await t.retry.calculateDelay({ + attemptCount: r, + retryOptions: t.retry, + error: A, + retryAfter: e, + computedValue: k.default({ + attemptCount: r, + retryOptions: t.retry, + error: A, + retryAfter: e, + computedValue: 0, + }), + })); + } catch (e) { + return void this._error(new Z(e.message, e, this)); + } + if (o) { + const t = async () => { + try { + for (const e of this.options.hooks.beforeRetry) + await e(this.options, A, r); + } catch (t) { + return void this._error(new Z(t.message, e, this)); + } + this.destroyed || + (this.destroy(), this.emit('retry', r, e)); + }; + return void (this[z] = setTimeout(t, o)); + } + } + this._error(A); + })(); + } + _read() { + this[G] = !0; + const e = this[K]; + if (e && !this[Y]) { + let t; + for ( + e.readableLength && (this[G] = !1); + null !== (t = e.read()); + + ) { + (this[R] += t.length), (this[j] = !0); + const e = this.downloadProgress; + e.percent < 1 && this.emit('downloadProgress', e), this.push(t); + } + } + } + _write(e, t, r) { + const A = () => { + this._writeRequest(e, t, r); + }; + this.requestInitialized ? A() : this[J].push(A); + } + _writeRequest(e, t, r) { + this[F].destroyed || + (this._progressCallbacks.push(() => { + this[L] += Buffer.byteLength(e, t); + const r = this.uploadProgress; + r.percent < 1 && this.emit('uploadProgress', r); + }), + this[F].write(e, t, (e) => { + e || + 0 === this._progressCallbacks.length || + this._progressCallbacks.shift()(), + r(e); + })); + } + _final(e) { + const t = () => { + for (; 0 !== this._progressCallbacks.length; ) + this._progressCallbacks.shift()(); + F in this + ? this[F].destroyed + ? e() + : this[F].end((t) => { + t || + ((this[x] = this[L]), + this.emit('uploadProgress', this.uploadProgress), + this[F].emit('upload-complete')), + e(t); + }) + : e(); + }; + this.requestInitialized ? t() : this[J].push(t); + } + _destroy(e, t) { + var r; + (this[Y] = !0), + clearTimeout(this[z]), + F in this && + (this[T](), + (null === (r = this[K]) || void 0 === r + ? void 0 + : r.complete) || this[F].destroy()), + null === e || + C.default.undefined(e) || + e instanceof Z || + (e = new Z(e.message, e, this)), + t(e); + } + get _isAboutToError() { + return this[Y]; + } + get ip() { + var e; + return null === (e = this[F]) || void 0 === e + ? void 0 + : e.socket.remoteAddress; + } + get aborted() { + var e, t, r; + return ( + (null !== + (t = + null === (e = this[F]) || void 0 === e + ? void 0 + : e.destroyed) && void 0 !== t + ? t + : this.destroyed) && + !(null === (r = this[q]) || void 0 === r ? void 0 : r.complete) + ); + } + get socket() { + var e; + return null === (e = this[F]) || void 0 === e ? void 0 : e.socket; + } + get downloadProgress() { + let e; + return ( + (e = this[M] ? this[R] / this[M] : this[M] === this[R] ? 1 : 0), + { percent: e, transferred: this[R], total: this[M] } + ); + } + get uploadProgress() { + let e; + return ( + (e = this[x] ? this[L] / this[x] : this[x] === this[L] ? 1 : 0), + { percent: e, transferred: this[L], total: this[x] } + ); + } + get timings() { + var e; + return null === (e = this[F]) || void 0 === e ? void 0 : e.timings; + } + get isFromCache() { + return this[U]; + } + pipe(e, t) { + if (this[j]) + throw new Error( + 'Failed to pipe. The response has been emitted already.' + ); + return ( + e instanceof a.ServerResponse && this[P].add(e), super.pipe(e, t) + ); + } + unpipe(e) { + return ( + e instanceof a.ServerResponse && this[P].delete(e), + super.unpipe(e), + this + ); + } + } + t.default = se; + }, + 11338: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.dnsLookupIpVersionToFamily = t.isDnsLookupIpVersion = void 0); + const r = { auto: 0, ipv4: 4, ipv6: 6 }; + (t.isDnsLookupIpVersion = (e) => e in r), + (t.dnsLookupIpVersionToFamily = (e) => { + if (t.isDnsLookupIpVersion(e)) return r[e]; + throw new Error('Invalid DNS lookup IP version'); + }); + }, + 78586: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(35747), + n = r(31669), + o = r(7966), + i = r(2920), + s = n.promisify(A.stat); + t.default = async (e, t) => { + if (t && 'content-length' in t) return Number(t['content-length']); + if (!e) return 0; + if (o.default.string(e)) return Buffer.byteLength(e); + if (o.default.buffer(e)) return e.length; + if (i.default(e)) return n.promisify(e.getLength.bind(e))(); + if (e instanceof A.ReadStream) { + const { size: t } = await s(e.path); + return t; + } + }; + }, + 57854: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + t.default = async (e) => { + const t = []; + let r = 0; + for await (const A of e) t.push(A), (r += Buffer.byteLength(A)); + return Buffer.isBuffer(t[0]) + ? Buffer.concat(t, r) + : Buffer.from(t.join('')); + }; + }, + 2920: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(7966); + t.default = (e) => + A.default.nodeStream(e) && A.default.function_(e.getBoundary); + }, + 38206: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.isResponseOk = void 0), + (t.isResponseOk = (e) => { + const { statusCode: t } = e, + r = e.request.options.followRedirect ? 299 : 399; + return (t >= 200 && t <= r) || 304 === t; + }); + }, + 82524: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(78835), + n = ['protocol', 'host', 'hostname', 'port', 'pathname', 'search']; + t.default = (e, t) => { + var r, o; + if (t.path) { + if (t.pathname) + throw new TypeError( + 'Parameters `path` and `pathname` are mutually exclusive.' + ); + if (t.search) + throw new TypeError( + 'Parameters `path` and `search` are mutually exclusive.' + ); + if (t.searchParams) + throw new TypeError( + 'Parameters `path` and `searchParams` are mutually exclusive.' + ); + } + if (t.search && t.searchParams) + throw new TypeError( + 'Parameters `search` and `searchParams` are mutually exclusive.' + ); + if (!e) { + if (!t.protocol) throw new TypeError('No URL protocol specified'); + e = `${t.protocol}//${ + null !== + (o = null !== (r = t.hostname) && void 0 !== r ? r : t.host) && + void 0 !== o + ? o + : '' + }`; + } + const i = new A.URL(e); + if (t.path) { + const e = t.path.indexOf('?'); + -1 === e + ? (t.pathname = t.path) + : ((t.pathname = t.path.slice(0, e)), + (t.search = t.path.slice(e + 1))), + delete t.path; + } + for (const e of n) t[e] && (i[e] = t[e].toString()); + return i; + }; + }, + 51743: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.default = function (e, t, r) { + const A = {}; + for (const n of r) + (A[n] = (...e) => { + t.emit(n, ...e); + }), + e.on(n, A[n]); + return () => { + for (const t of r) e.off(t, A[t]); + }; + }); + }, + 44947: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.TimeoutError = void 0); + const A = r(11631), + n = r(70148), + o = Symbol('reentry'), + i = () => {}; + class s extends Error { + constructor(e, t) { + super(`Timeout awaiting '${t}' for ${e}ms`), + (this.event = t), + (this.name = 'TimeoutError'), + (this.code = 'ETIMEDOUT'); + } + } + (t.TimeoutError = s), + (t.default = (e, t, r) => { + if (o in e) return i; + e[o] = !0; + const a = [], + { once: c, unhandleAll: g } = n.default(), + l = (e, t, r) => { + var A; + const n = setTimeout(t, e, e, r); + null === (A = n.unref) || void 0 === A || A.call(n); + const o = () => { + clearTimeout(n); + }; + return a.push(o), o; + }, + { host: u, hostname: h } = r, + p = (t, r) => { + e.destroy(new s(t, r)); + }, + d = () => { + for (const e of a) e(); + g(); + }; + if ( + (e.once('error', (t) => { + if ((d(), 0 === e.listenerCount('error'))) throw t; + }), + e.once('close', d), + c(e, 'response', (e) => { + c(e, 'end', d); + }), + void 0 !== t.request && l(t.request, p, 'request'), + void 0 !== t.socket) + ) { + const r = () => { + p(t.socket, 'socket'); + }; + e.setTimeout(t.socket, r), + a.push(() => { + e.removeListener('timeout', r); + }); + } + return ( + c(e, 'socket', (n) => { + var o; + const { socketPath: i } = e; + if (n.connecting) { + const e = Boolean( + null != i + ? i + : 0 !== + A.isIP( + null !== (o = null != h ? h : u) && void 0 !== o + ? o + : '' + ) + ); + if ( + void 0 !== t.lookup && + !e && + void 0 === n.address().address + ) { + const e = l(t.lookup, p, 'lookup'); + c(n, 'lookup', e); + } + if (void 0 !== t.connect) { + const r = () => l(t.connect, p, 'connect'); + e + ? c(n, 'connect', r()) + : c(n, 'lookup', (e) => { + null === e && c(n, 'connect', r()); + }); + } + void 0 !== t.secureConnect && + 'https:' === r.protocol && + c(n, 'connect', () => { + const e = l(t.secureConnect, p, 'secureConnect'); + c(n, 'secureConnect', e); + }); + } + if (void 0 !== t.send) { + const r = () => l(t.send, p, 'send'); + n.connecting + ? c(n, 'connect', () => { + c(e, 'upload-complete', r()); + }) + : c(e, 'upload-complete', r()); + } + }), + void 0 !== t.response && + c(e, 'upload-complete', () => { + const r = l(t.response, p, 'response'); + c(e, 'response', r); + }), + d + ); + }); + }, + 70148: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.default = () => { + const e = []; + return { + once(t, r, A) { + t.once(r, A), e.push({ origin: t, event: r, fn: A }); + }, + unhandleAll() { + for (const t of e) { + const { origin: e, event: r, fn: A } = t; + e.removeListener(r, A); + } + e.length = 0; + }, + }; + }); + }, + 50116: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(7966); + t.default = (e) => { + const t = { + protocol: (e = e).protocol, + hostname: + A.default.string(e.hostname) && e.hostname.startsWith('[') + ? e.hostname.slice(1, -1) + : e.hostname, + host: e.host, + hash: e.hash, + search: e.search, + pathname: e.pathname, + href: e.href, + path: `${e.pathname || ''}${e.search || ''}`, + }; + return ( + A.default.string(e.port) && + 0 !== e.port.length && + (t.port = Number(e.port)), + (e.username || e.password) && + (t.auth = `${e.username || ''}:${e.password || ''}`), + t + ); + }; + }, + 85551: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + t.default = class { + constructor() { + (this.weakMap = new WeakMap()), (this.map = new Map()); + } + set(e, t) { + 'object' == typeof e ? this.weakMap.set(e, t) : this.map.set(e, t); + } + get(e) { + return 'object' == typeof e ? this.weakMap.get(e) : this.map.get(e); + } + has(e) { + return 'object' == typeof e ? this.weakMap.has(e) : this.map.has(e); + } + }; + }, + 39226: function (e, t, r) { + 'use strict'; + var A = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, A) { + void 0 === A && (A = r), + Object.defineProperty(e, A, { + enumerable: !0, + get: function () { + return t[r]; + }, + }); + } + : function (e, t, r, A) { + void 0 === A && (A = r), (e[A] = t[r]); + }), + n = + (this && this.__exportStar) || + function (e, t) { + for (var r in e) + 'default' === r || + Object.prototype.hasOwnProperty.call(t, r) || + A(t, e, r); + }; + Object.defineProperty(t, '__esModule', { value: !0 }), + (t.defaultHandler = void 0); + const o = r(7966), + i = r(81588), + s = r(93576), + a = r(9048), + c = r(9743), + g = { + RequestError: i.RequestError, + CacheError: i.CacheError, + ReadError: i.ReadError, + HTTPError: i.HTTPError, + MaxRedirectsError: i.MaxRedirectsError, + TimeoutError: i.TimeoutError, + ParseError: i.ParseError, + CancelError: i.CancelError, + UnsupportedProtocolError: i.UnsupportedProtocolError, + UploadError: i.UploadError, + }, + l = async (e) => + new Promise((t) => { + setTimeout(t, e); + }), + { normalizeArguments: u } = a.default, + h = (...e) => { + let t; + for (const r of e) t = u(void 0, r, t); + return t; + }, + p = (e) => (e.isStream ? new a.default(void 0, e) : i.default(e)), + d = (e) => 'defaults' in e && 'options' in e.defaults, + C = ['get', 'post', 'put', 'patch', 'head', 'delete']; + t.defaultHandler = (e, t) => t(e); + const f = (e, t) => { + if (e) for (const r of e) r(t); + }, + I = (e) => { + (e._rawHandlers = e.handlers), + (e.handlers = e.handlers.map((e) => (t, r) => { + let A; + const n = e(t, (e) => ((A = r(e)), A)); + if (n !== A && !t.isStream && A) { + const e = n, + { then: t, catch: r, finally: o } = e; + Object.setPrototypeOf(e, Object.getPrototypeOf(A)), + Object.defineProperties( + e, + Object.getOwnPropertyDescriptors(A) + ), + (e.then = t), + (e.catch = r), + (e.finally = o); + } + return n; + })); + const r = (t, r, A) => { + var n, c; + let g = 0; + const l = (t) => + e.handlers[g++](t, g === e.handlers.length ? p : l); + if (o.default.plainObject(t)) { + const e = { ...t, ...r }; + a.setNonEnumerableProperties([t, r], e), (r = e), (t = void 0); + } + try { + let o; + try { + f(e.options.hooks.init, r), + f( + null === (n = null == r ? void 0 : r.hooks) || + void 0 === n + ? void 0 + : n.init, + r + ); + } catch (e) { + o = e; + } + const s = u(t, r, null != A ? A : e.options); + if (((s[a.kIsNormalizedAlready] = !0), o)) + throw new i.RequestError(o.message, o, s); + return l(s); + } catch (t) { + if (null == r ? void 0 : r.isStream) throw t; + return s.default( + t, + e.options.hooks.beforeError, + null === (c = null == r ? void 0 : r.hooks) || void 0 === c + ? void 0 + : c.beforeError + ); + } + }; + r.extend = (...r) => { + const A = [e.options]; + let n, + o = [...e._rawHandlers]; + for (const e of r) + d(e) + ? (A.push(e.defaults.options), + o.push(...e.defaults._rawHandlers), + (n = e.defaults.mutableDefaults)) + : (A.push(e), + 'handlers' in e && o.push(...e.handlers), + (n = e.mutableDefaults)); + return ( + (o = o.filter((e) => e !== t.defaultHandler)), + 0 === o.length && o.push(t.defaultHandler), + I({ + options: h(...A), + handlers: o, + mutableDefaults: Boolean(n), + }) + ); + }; + const A = async function* (t, A) { + let n = u(t, A, e.options); + n.resolveBodyOnly = !1; + const i = n.pagination; + if (!o.default.object(i)) + throw new TypeError('`options.pagination` must be implemented'); + const s = []; + let { countLimit: a } = i, + c = 0; + for (; c < i.requestLimit; ) { + 0 !== c && (await l(i.backoff)); + const e = await r(void 0, void 0, n), + t = await i.transform(e), + A = []; + for (const e of t) + if (i.filter(e, s, A)) { + if (!i.shouldContinue(e, s, A)) return; + if ( + (yield e, + i.stackAllItems && s.push(e), + A.push(e), + --a <= 0) + ) + return; + } + const o = i.paginate(e, s, A); + if (!1 === o) return; + o === e.request.options + ? (n = e.request.options) + : void 0 !== o && (n = u(void 0, o, n)), + c++; + } + }; + ((r.paginate = A).all = async (e, t) => { + const r = []; + for await (const n of A(e, t)) r.push(n); + return r; + }), + (r.paginate.each = A), + (r.stream = (e, t) => r(e, { ...t, isStream: !0 })); + for (const e of C) + (r[e] = (t, A) => r(t, { ...A, method: e })), + (r.stream[e] = (t, A) => + r(t, { ...A, method: e, isStream: !0 })); + return ( + Object.assign(r, g), + Object.defineProperty(r, 'defaults', { + value: e.mutableDefaults ? e : c.default(e), + writable: e.mutableDefaults, + configurable: e.mutableDefaults, + enumerable: !0, + }), + (r.mergeOptions = h), + r + ); + }; + (t.default = I), n(r(69022), t); + }, + 48722: function (e, t, r) { + 'use strict'; + var A = + (this && this.__createBinding) || + (Object.create + ? function (e, t, r, A) { + void 0 === A && (A = r), + Object.defineProperty(e, A, { + enumerable: !0, + get: function () { + return t[r]; + }, + }); + } + : function (e, t, r, A) { + void 0 === A && (A = r), (e[A] = t[r]); + }), + n = + (this && this.__exportStar) || + function (e, t) { + for (var r in e) + 'default' === r || + Object.prototype.hasOwnProperty.call(t, r) || + A(t, e, r); + }; + Object.defineProperty(t, '__esModule', { value: !0 }); + const o = r(78835), + i = r(39226), + s = { + 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: void 0, + calculateDelay: ({ computedValue: e }) => e, + }, + timeout: {}, + headers: { + 'user-agent': 'got (https://github.com/sindresorhus/got)', + }, + hooks: { + init: [], + beforeRequest: [], + beforeRedirect: [], + beforeRetry: [], + beforeError: [], + afterResponse: [], + }, + cache: void 0, + dnsCache: void 0, + decompress: !0, + throwHttpErrors: !0, + followRedirect: !0, + isStream: !1, + responseType: 'text', + resolveBodyOnly: !1, + maxRedirects: 10, + prefixUrl: '', + methodRewriting: !0, + ignoreInvalidCookies: !1, + context: {}, + http2: !1, + allowGetBody: !1, + https: void 0, + pagination: { + transform: (e) => + 'json' === e.request.options.responseType + ? e.body + : JSON.parse(e.body), + paginate: (e) => { + if (!Reflect.has(e.headers, 'link')) return !1; + const t = e.headers.link.split(','); + let r; + for (const e of t) { + const t = e.split(';'); + if (t[1].includes('next')) { + (r = t[0].trimStart().trim()), (r = r.slice(1, -1)); + break; + } + } + if (r) { + return { url: new o.URL(r) }; + } + return !1; + }, + filter: () => !0, + shouldContinue: () => !0, + countLimit: 1 / 0, + backoff: 0, + requestLimit: 1e4, + stackAllItems: !0, + }, + parseJson: (e) => JSON.parse(e), + stringifyJson: (e) => JSON.stringify(e), + cacheOptions: {}, + }, + handlers: [i.defaultHandler], + mutableDefaults: !1, + }, + a = i.default(s); + (t.default = a), + (e.exports = a), + (e.exports.default = a), + (e.exports.__esModule = !0), + n(r(39226), t), + n(r(81588), t); + }, + 69022: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + }, + 9743: (e, t, r) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const A = r(7966); + t.default = function e(t) { + for (const r of Object.values(t)) + (A.default.plainObject(r) || A.default.array(r)) && e(r); + return Object.freeze(t); + }; + }, + 54595: (e, t) => { + 'use strict'; + Object.defineProperty(t, '__esModule', { value: !0 }); + const r = new Set(); + t.default = (e) => { + r.has(e) || + (r.add(e), + process.emitWarning('Got: ' + e, { type: 'DeprecationWarning' })); + }; + }, + 74988: (e) => { + e.exports && + (e.exports = function () { + var e = 3, + t = 4, + r = 12, + A = 13, + n = 16, + o = 17; + function i(e, t) { + void 0 === t && (t = 0); + var r = e.charCodeAt(t); + if (55296 <= r && r <= 56319 && t < e.length - 1) { + var A = r; + return 56320 <= (n = e.charCodeAt(t + 1)) && n <= 57343 + ? 1024 * (A - 55296) + (n - 56320) + 65536 + : A; + } + if (56320 <= r && r <= 57343 && t >= 1) { + var n = r; + return 55296 <= (A = e.charCodeAt(t - 1)) && A <= 56319 + ? 1024 * (A - 55296) + (n - 56320) + 65536 + : n; + } + return r; + } + function s(i, s, a) { + var c = [i].concat(s).concat([a]), + g = c[c.length - 2], + l = a, + u = c.lastIndexOf(14); + if ( + u > 1 && + c.slice(1, u).every(function (t) { + return t == e; + }) && + -1 == [e, A, o].indexOf(i) + ) + return 2; + var h = c.lastIndexOf(t); + if ( + h > 0 && + c.slice(1, h).every(function (e) { + return e == t; + }) && + -1 == [r, t].indexOf(g) + ) + return c.filter(function (e) { + return e == t; + }).length % + 2 == + 1 + ? 3 + : 4; + if (0 == g && 1 == l) return 0; + if (2 == g || 0 == g || 1 == g) + return 14 == l && + s.every(function (t) { + return t == e; + }) + ? 2 + : 1; + if (2 == l || 0 == l || 1 == l) return 1; + if (6 == g && (6 == l || 7 == l || 9 == l || 10 == l)) return 0; + if (!((9 != g && 7 != g) || (7 != l && 8 != l))) return 0; + if ((10 == g || 8 == g) && 8 == l) return 0; + if (l == e || 15 == l) return 0; + if (5 == l) return 0; + if (g == r) return 0; + var p = -1 != c.indexOf(e) ? c.lastIndexOf(e) - 1 : c.length - 2; + return (-1 != [A, o].indexOf(c[p]) && + c.slice(p + 1, -1).every(function (t) { + return t == e; + }) && + 14 == l) || + (15 == g && -1 != [n, o].indexOf(l)) + ? 0 + : -1 != s.indexOf(t) + ? 2 + : g == t && l == t + ? 0 + : 1; + } + function a(i) { + return (1536 <= i && i <= 1541) || + 1757 == i || + 1807 == i || + 2274 == i || + 3406 == i || + 69821 == i || + (70082 <= i && i <= 70083) || + 72250 == i || + (72326 <= i && i <= 72329) || + 73030 == i + ? r + : 13 == i + ? 0 + : 10 == i + ? 1 + : (0 <= i && i <= 9) || + (11 <= i && i <= 12) || + (14 <= i && i <= 31) || + (127 <= i && i <= 159) || + 173 == i || + 1564 == i || + 6158 == i || + 8203 == i || + (8206 <= i && i <= 8207) || + 8232 == i || + 8233 == i || + (8234 <= i && i <= 8238) || + (8288 <= i && i <= 8292) || + 8293 == i || + (8294 <= i && i <= 8303) || + (55296 <= i && i <= 57343) || + 65279 == i || + (65520 <= i && i <= 65528) || + (65529 <= i && i <= 65531) || + (113824 <= i && i <= 113827) || + (119155 <= i && i <= 119162) || + 917504 == i || + 917505 == i || + (917506 <= i && i <= 917535) || + (917632 <= i && i <= 917759) || + (918e3 <= i && i <= 921599) + ? 2 + : (768 <= i && i <= 879) || + (1155 <= i && i <= 1159) || + (1160 <= i && i <= 1161) || + (1425 <= i && i <= 1469) || + 1471 == i || + (1473 <= i && i <= 1474) || + (1476 <= i && i <= 1477) || + 1479 == i || + (1552 <= i && i <= 1562) || + (1611 <= i && i <= 1631) || + 1648 == i || + (1750 <= i && i <= 1756) || + (1759 <= i && i <= 1764) || + (1767 <= i && i <= 1768) || + (1770 <= i && i <= 1773) || + 1809 == i || + (1840 <= i && i <= 1866) || + (1958 <= i && i <= 1968) || + (2027 <= i && i <= 2035) || + (2070 <= i && i <= 2073) || + (2075 <= i && i <= 2083) || + (2085 <= i && i <= 2087) || + (2089 <= i && i <= 2093) || + (2137 <= i && i <= 2139) || + (2260 <= i && i <= 2273) || + (2275 <= i && i <= 2306) || + 2362 == i || + 2364 == i || + (2369 <= i && i <= 2376) || + 2381 == i || + (2385 <= i && i <= 2391) || + (2402 <= i && i <= 2403) || + 2433 == i || + 2492 == i || + 2494 == i || + (2497 <= i && i <= 2500) || + 2509 == i || + 2519 == i || + (2530 <= i && i <= 2531) || + (2561 <= i && i <= 2562) || + 2620 == i || + (2625 <= i && i <= 2626) || + (2631 <= i && i <= 2632) || + (2635 <= i && i <= 2637) || + 2641 == i || + (2672 <= i && i <= 2673) || + 2677 == i || + (2689 <= i && i <= 2690) || + 2748 == i || + (2753 <= i && i <= 2757) || + (2759 <= i && i <= 2760) || + 2765 == i || + (2786 <= i && i <= 2787) || + (2810 <= i && i <= 2815) || + 2817 == i || + 2876 == i || + 2878 == i || + 2879 == i || + (2881 <= i && i <= 2884) || + 2893 == i || + 2902 == i || + 2903 == i || + (2914 <= i && i <= 2915) || + 2946 == i || + 3006 == i || + 3008 == i || + 3021 == i || + 3031 == i || + 3072 == i || + (3134 <= i && i <= 3136) || + (3142 <= i && i <= 3144) || + (3146 <= i && i <= 3149) || + (3157 <= i && i <= 3158) || + (3170 <= i && i <= 3171) || + 3201 == i || + 3260 == i || + 3263 == i || + 3266 == i || + 3270 == i || + (3276 <= i && i <= 3277) || + (3285 <= i && i <= 3286) || + (3298 <= i && i <= 3299) || + (3328 <= i && i <= 3329) || + (3387 <= i && i <= 3388) || + 3390 == i || + (3393 <= i && i <= 3396) || + 3405 == i || + 3415 == i || + (3426 <= i && i <= 3427) || + 3530 == i || + 3535 == i || + (3538 <= i && i <= 3540) || + 3542 == i || + 3551 == i || + 3633 == i || + (3636 <= i && i <= 3642) || + (3655 <= i && i <= 3662) || + 3761 == i || + (3764 <= i && i <= 3769) || + (3771 <= i && i <= 3772) || + (3784 <= i && i <= 3789) || + (3864 <= i && i <= 3865) || + 3893 == i || + 3895 == i || + 3897 == i || + (3953 <= i && i <= 3966) || + (3968 <= i && i <= 3972) || + (3974 <= i && i <= 3975) || + (3981 <= i && i <= 3991) || + (3993 <= i && i <= 4028) || + 4038 == i || + (4141 <= i && i <= 4144) || + (4146 <= i && i <= 4151) || + (4153 <= i && i <= 4154) || + (4157 <= i && i <= 4158) || + (4184 <= i && i <= 4185) || + (4190 <= i && i <= 4192) || + (4209 <= i && i <= 4212) || + 4226 == i || + (4229 <= i && i <= 4230) || + 4237 == i || + 4253 == i || + (4957 <= i && i <= 4959) || + (5906 <= i && i <= 5908) || + (5938 <= i && i <= 5940) || + (5970 <= i && i <= 5971) || + (6002 <= i && i <= 6003) || + (6068 <= i && i <= 6069) || + (6071 <= i && i <= 6077) || + 6086 == i || + (6089 <= i && i <= 6099) || + 6109 == i || + (6155 <= i && i <= 6157) || + (6277 <= i && i <= 6278) || + 6313 == i || + (6432 <= i && i <= 6434) || + (6439 <= i && i <= 6440) || + 6450 == i || + (6457 <= i && i <= 6459) || + (6679 <= i && i <= 6680) || + 6683 == i || + 6742 == i || + (6744 <= i && i <= 6750) || + 6752 == i || + 6754 == i || + (6757 <= i && i <= 6764) || + (6771 <= i && i <= 6780) || + 6783 == i || + (6832 <= i && i <= 6845) || + 6846 == i || + (6912 <= i && i <= 6915) || + 6964 == i || + (6966 <= i && i <= 6970) || + 6972 == i || + 6978 == i || + (7019 <= i && i <= 7027) || + (7040 <= i && i <= 7041) || + (7074 <= i && i <= 7077) || + (7080 <= i && i <= 7081) || + (7083 <= i && i <= 7085) || + 7142 == i || + (7144 <= i && i <= 7145) || + 7149 == i || + (7151 <= i && i <= 7153) || + (7212 <= i && i <= 7219) || + (7222 <= i && i <= 7223) || + (7376 <= i && i <= 7378) || + (7380 <= i && i <= 7392) || + (7394 <= i && i <= 7400) || + 7405 == i || + 7412 == i || + (7416 <= i && i <= 7417) || + (7616 <= i && i <= 7673) || + (7675 <= i && i <= 7679) || + 8204 == i || + (8400 <= i && i <= 8412) || + (8413 <= i && i <= 8416) || + 8417 == i || + (8418 <= i && i <= 8420) || + (8421 <= i && i <= 8432) || + (11503 <= i && i <= 11505) || + 11647 == i || + (11744 <= i && i <= 11775) || + (12330 <= i && i <= 12333) || + (12334 <= i && i <= 12335) || + (12441 <= i && i <= 12442) || + 42607 == i || + (42608 <= i && i <= 42610) || + (42612 <= i && i <= 42621) || + (42654 <= i && i <= 42655) || + (42736 <= i && i <= 42737) || + 43010 == i || + 43014 == i || + 43019 == i || + (43045 <= i && i <= 43046) || + (43204 <= i && i <= 43205) || + (43232 <= i && i <= 43249) || + (43302 <= i && i <= 43309) || + (43335 <= i && i <= 43345) || + (43392 <= i && i <= 43394) || + 43443 == i || + (43446 <= i && i <= 43449) || + 43452 == i || + 43493 == i || + (43561 <= i && i <= 43566) || + (43569 <= i && i <= 43570) || + (43573 <= i && i <= 43574) || + 43587 == i || + 43596 == i || + 43644 == i || + 43696 == i || + (43698 <= i && i <= 43700) || + (43703 <= i && i <= 43704) || + (43710 <= i && i <= 43711) || + 43713 == i || + (43756 <= i && i <= 43757) || + 43766 == i || + 44005 == i || + 44008 == i || + 44013 == i || + 64286 == i || + (65024 <= i && i <= 65039) || + (65056 <= i && i <= 65071) || + (65438 <= i && i <= 65439) || + 66045 == i || + 66272 == i || + (66422 <= i && i <= 66426) || + (68097 <= i && i <= 68099) || + (68101 <= i && i <= 68102) || + (68108 <= i && i <= 68111) || + (68152 <= i && i <= 68154) || + 68159 == i || + (68325 <= i && i <= 68326) || + 69633 == i || + (69688 <= i && i <= 69702) || + (69759 <= i && i <= 69761) || + (69811 <= i && i <= 69814) || + (69817 <= i && i <= 69818) || + (69888 <= i && i <= 69890) || + (69927 <= i && i <= 69931) || + (69933 <= i && i <= 69940) || + 70003 == i || + (70016 <= i && i <= 70017) || + (70070 <= i && i <= 70078) || + (70090 <= i && i <= 70092) || + (70191 <= i && i <= 70193) || + 70196 == i || + (70198 <= i && i <= 70199) || + 70206 == i || + 70367 == i || + (70371 <= i && i <= 70378) || + (70400 <= i && i <= 70401) || + 70460 == i || + 70462 == i || + 70464 == i || + 70487 == i || + (70502 <= i && i <= 70508) || + (70512 <= i && i <= 70516) || + (70712 <= i && i <= 70719) || + (70722 <= i && i <= 70724) || + 70726 == i || + 70832 == i || + (70835 <= i && i <= 70840) || + 70842 == i || + 70845 == i || + (70847 <= i && i <= 70848) || + (70850 <= i && i <= 70851) || + 71087 == i || + (71090 <= i && i <= 71093) || + (71100 <= i && i <= 71101) || + (71103 <= i && i <= 71104) || + (71132 <= i && i <= 71133) || + (71219 <= i && i <= 71226) || + 71229 == i || + (71231 <= i && i <= 71232) || + 71339 == i || + 71341 == i || + (71344 <= i && i <= 71349) || + 71351 == i || + (71453 <= i && i <= 71455) || + (71458 <= i && i <= 71461) || + (71463 <= i && i <= 71467) || + (72193 <= i && i <= 72198) || + (72201 <= i && i <= 72202) || + (72243 <= i && i <= 72248) || + (72251 <= i && i <= 72254) || + 72263 == i || + (72273 <= i && i <= 72278) || + (72281 <= i && i <= 72283) || + (72330 <= i && i <= 72342) || + (72344 <= i && i <= 72345) || + (72752 <= i && i <= 72758) || + (72760 <= i && i <= 72765) || + 72767 == i || + (72850 <= i && i <= 72871) || + (72874 <= i && i <= 72880) || + (72882 <= i && i <= 72883) || + (72885 <= i && i <= 72886) || + (73009 <= i && i <= 73014) || + 73018 == i || + (73020 <= i && i <= 73021) || + (73023 <= i && i <= 73029) || + 73031 == i || + (92912 <= i && i <= 92916) || + (92976 <= i && i <= 92982) || + (94095 <= i && i <= 94098) || + (113821 <= i && i <= 113822) || + 119141 == i || + (119143 <= i && i <= 119145) || + (119150 <= i && i <= 119154) || + (119163 <= i && i <= 119170) || + (119173 <= i && i <= 119179) || + (119210 <= i && i <= 119213) || + (119362 <= i && i <= 119364) || + (121344 <= i && i <= 121398) || + (121403 <= i && i <= 121452) || + 121461 == i || + 121476 == i || + (121499 <= i && i <= 121503) || + (121505 <= i && i <= 121519) || + (122880 <= i && i <= 122886) || + (122888 <= i && i <= 122904) || + (122907 <= i && i <= 122913) || + (122915 <= i && i <= 122916) || + (122918 <= i && i <= 122922) || + (125136 <= i && i <= 125142) || + (125252 <= i && i <= 125258) || + (917536 <= i && i <= 917631) || + (917760 <= i && i <= 917999) + ? e + : 127462 <= i && i <= 127487 + ? t + : 2307 == i || + 2363 == i || + (2366 <= i && i <= 2368) || + (2377 <= i && i <= 2380) || + (2382 <= i && i <= 2383) || + (2434 <= i && i <= 2435) || + (2495 <= i && i <= 2496) || + (2503 <= i && i <= 2504) || + (2507 <= i && i <= 2508) || + 2563 == i || + (2622 <= i && i <= 2624) || + 2691 == i || + (2750 <= i && i <= 2752) || + 2761 == i || + (2763 <= i && i <= 2764) || + (2818 <= i && i <= 2819) || + 2880 == i || + (2887 <= i && i <= 2888) || + (2891 <= i && i <= 2892) || + 3007 == i || + (3009 <= i && i <= 3010) || + (3014 <= i && i <= 3016) || + (3018 <= i && i <= 3020) || + (3073 <= i && i <= 3075) || + (3137 <= i && i <= 3140) || + (3202 <= i && i <= 3203) || + 3262 == i || + (3264 <= i && i <= 3265) || + (3267 <= i && i <= 3268) || + (3271 <= i && i <= 3272) || + (3274 <= i && i <= 3275) || + (3330 <= i && i <= 3331) || + (3391 <= i && i <= 3392) || + (3398 <= i && i <= 3400) || + (3402 <= i && i <= 3404) || + (3458 <= i && i <= 3459) || + (3536 <= i && i <= 3537) || + (3544 <= i && i <= 3550) || + (3570 <= i && i <= 3571) || + 3635 == i || + 3763 == i || + (3902 <= i && i <= 3903) || + 3967 == i || + 4145 == i || + (4155 <= i && i <= 4156) || + (4182 <= i && i <= 4183) || + 4228 == i || + 6070 == i || + (6078 <= i && i <= 6085) || + (6087 <= i && i <= 6088) || + (6435 <= i && i <= 6438) || + (6441 <= i && i <= 6443) || + (6448 <= i && i <= 6449) || + (6451 <= i && i <= 6456) || + (6681 <= i && i <= 6682) || + 6741 == i || + 6743 == i || + (6765 <= i && i <= 6770) || + 6916 == i || + 6965 == i || + 6971 == i || + (6973 <= i && i <= 6977) || + (6979 <= i && i <= 6980) || + 7042 == i || + 7073 == i || + (7078 <= i && i <= 7079) || + 7082 == i || + 7143 == i || + (7146 <= i && i <= 7148) || + 7150 == i || + (7154 <= i && i <= 7155) || + (7204 <= i && i <= 7211) || + (7220 <= i && i <= 7221) || + 7393 == i || + (7410 <= i && i <= 7411) || + 7415 == i || + (43043 <= i && i <= 43044) || + 43047 == i || + (43136 <= i && i <= 43137) || + (43188 <= i && i <= 43203) || + (43346 <= i && i <= 43347) || + 43395 == i || + (43444 <= i && i <= 43445) || + (43450 <= i && i <= 43451) || + (43453 <= i && i <= 43456) || + (43567 <= i && i <= 43568) || + (43571 <= i && i <= 43572) || + 43597 == i || + 43755 == i || + (43758 <= i && i <= 43759) || + 43765 == i || + (44003 <= i && i <= 44004) || + (44006 <= i && i <= 44007) || + (44009 <= i && i <= 44010) || + 44012 == i || + 69632 == i || + 69634 == i || + 69762 == i || + (69808 <= i && i <= 69810) || + (69815 <= i && i <= 69816) || + 69932 == i || + 70018 == i || + (70067 <= i && i <= 70069) || + (70079 <= i && i <= 70080) || + (70188 <= i && i <= 70190) || + (70194 <= i && i <= 70195) || + 70197 == i || + (70368 <= i && i <= 70370) || + (70402 <= i && i <= 70403) || + 70463 == i || + (70465 <= i && i <= 70468) || + (70471 <= i && i <= 70472) || + (70475 <= i && i <= 70477) || + (70498 <= i && i <= 70499) || + (70709 <= i && i <= 70711) || + (70720 <= i && i <= 70721) || + 70725 == i || + (70833 <= i && i <= 70834) || + 70841 == i || + (70843 <= i && i <= 70844) || + 70846 == i || + 70849 == i || + (71088 <= i && i <= 71089) || + (71096 <= i && i <= 71099) || + 71102 == i || + (71216 <= i && i <= 71218) || + (71227 <= i && i <= 71228) || + 71230 == i || + 71340 == i || + (71342 <= i && i <= 71343) || + 71350 == i || + (71456 <= i && i <= 71457) || + 71462 == i || + (72199 <= i && i <= 72200) || + 72249 == i || + (72279 <= i && i <= 72280) || + 72343 == i || + 72751 == i || + 72766 == i || + 72873 == i || + 72881 == i || + 72884 == i || + (94033 <= i && i <= 94078) || + 119142 == i || + 119149 == i + ? 5 + : (4352 <= i && i <= 4447) || (43360 <= i && i <= 43388) + ? 6 + : (4448 <= i && i <= 4519) || (55216 <= i && i <= 55238) + ? 7 + : (4520 <= i && i <= 4607) || (55243 <= i && i <= 55291) + ? 8 + : 44032 == i || + 44060 == i || + 44088 == i || + 44116 == i || + 44144 == i || + 44172 == i || + 44200 == i || + 44228 == i || + 44256 == i || + 44284 == i || + 44312 == i || + 44340 == i || + 44368 == i || + 44396 == i || + 44424 == i || + 44452 == i || + 44480 == i || + 44508 == i || + 44536 == i || + 44564 == i || + 44592 == i || + 44620 == i || + 44648 == i || + 44676 == i || + 44704 == i || + 44732 == i || + 44760 == i || + 44788 == i || + 44816 == i || + 44844 == i || + 44872 == i || + 44900 == i || + 44928 == i || + 44956 == i || + 44984 == i || + 45012 == i || + 45040 == i || + 45068 == i || + 45096 == i || + 45124 == i || + 45152 == i || + 45180 == i || + 45208 == i || + 45236 == i || + 45264 == i || + 45292 == i || + 45320 == i || + 45348 == i || + 45376 == i || + 45404 == i || + 45432 == i || + 45460 == i || + 45488 == i || + 45516 == i || + 45544 == i || + 45572 == i || + 45600 == i || + 45628 == i || + 45656 == i || + 45684 == i || + 45712 == i || + 45740 == i || + 45768 == i || + 45796 == i || + 45824 == i || + 45852 == i || + 45880 == i || + 45908 == i || + 45936 == i || + 45964 == i || + 45992 == i || + 46020 == i || + 46048 == i || + 46076 == i || + 46104 == i || + 46132 == i || + 46160 == i || + 46188 == i || + 46216 == i || + 46244 == i || + 46272 == i || + 46300 == i || + 46328 == i || + 46356 == i || + 46384 == i || + 46412 == i || + 46440 == i || + 46468 == i || + 46496 == i || + 46524 == i || + 46552 == i || + 46580 == i || + 46608 == i || + 46636 == i || + 46664 == i || + 46692 == i || + 46720 == i || + 46748 == i || + 46776 == i || + 46804 == i || + 46832 == i || + 46860 == i || + 46888 == i || + 46916 == i || + 46944 == i || + 46972 == i || + 47e3 == i || + 47028 == i || + 47056 == i || + 47084 == i || + 47112 == i || + 47140 == i || + 47168 == i || + 47196 == i || + 47224 == i || + 47252 == i || + 47280 == i || + 47308 == i || + 47336 == i || + 47364 == i || + 47392 == i || + 47420 == i || + 47448 == i || + 47476 == i || + 47504 == i || + 47532 == i || + 47560 == i || + 47588 == i || + 47616 == i || + 47644 == i || + 47672 == i || + 47700 == i || + 47728 == i || + 47756 == i || + 47784 == i || + 47812 == i || + 47840 == i || + 47868 == i || + 47896 == i || + 47924 == i || + 47952 == i || + 47980 == i || + 48008 == i || + 48036 == i || + 48064 == i || + 48092 == i || + 48120 == i || + 48148 == i || + 48176 == i || + 48204 == i || + 48232 == i || + 48260 == i || + 48288 == i || + 48316 == i || + 48344 == i || + 48372 == i || + 48400 == i || + 48428 == i || + 48456 == i || + 48484 == i || + 48512 == i || + 48540 == i || + 48568 == i || + 48596 == i || + 48624 == i || + 48652 == i || + 48680 == i || + 48708 == i || + 48736 == i || + 48764 == i || + 48792 == i || + 48820 == i || + 48848 == i || + 48876 == i || + 48904 == i || + 48932 == i || + 48960 == i || + 48988 == i || + 49016 == i || + 49044 == i || + 49072 == i || + 49100 == i || + 49128 == i || + 49156 == i || + 49184 == i || + 49212 == i || + 49240 == i || + 49268 == i || + 49296 == i || + 49324 == i || + 49352 == i || + 49380 == i || + 49408 == i || + 49436 == i || + 49464 == i || + 49492 == i || + 49520 == i || + 49548 == i || + 49576 == i || + 49604 == i || + 49632 == i || + 49660 == i || + 49688 == i || + 49716 == i || + 49744 == i || + 49772 == i || + 49800 == i || + 49828 == i || + 49856 == i || + 49884 == i || + 49912 == i || + 49940 == i || + 49968 == i || + 49996 == i || + 50024 == i || + 50052 == i || + 50080 == i || + 50108 == i || + 50136 == i || + 50164 == i || + 50192 == i || + 50220 == i || + 50248 == i || + 50276 == i || + 50304 == i || + 50332 == i || + 50360 == i || + 50388 == i || + 50416 == i || + 50444 == i || + 50472 == i || + 50500 == i || + 50528 == i || + 50556 == i || + 50584 == i || + 50612 == i || + 50640 == i || + 50668 == i || + 50696 == i || + 50724 == i || + 50752 == i || + 50780 == i || + 50808 == i || + 50836 == i || + 50864 == i || + 50892 == i || + 50920 == i || + 50948 == i || + 50976 == i || + 51004 == i || + 51032 == i || + 51060 == i || + 51088 == i || + 51116 == i || + 51144 == i || + 51172 == i || + 51200 == i || + 51228 == i || + 51256 == i || + 51284 == i || + 51312 == i || + 51340 == i || + 51368 == i || + 51396 == i || + 51424 == i || + 51452 == i || + 51480 == i || + 51508 == i || + 51536 == i || + 51564 == i || + 51592 == i || + 51620 == i || + 51648 == i || + 51676 == i || + 51704 == i || + 51732 == i || + 51760 == i || + 51788 == i || + 51816 == i || + 51844 == i || + 51872 == i || + 51900 == i || + 51928 == i || + 51956 == i || + 51984 == i || + 52012 == i || + 52040 == i || + 52068 == i || + 52096 == i || + 52124 == i || + 52152 == i || + 52180 == i || + 52208 == i || + 52236 == i || + 52264 == i || + 52292 == i || + 52320 == i || + 52348 == i || + 52376 == i || + 52404 == i || + 52432 == i || + 52460 == i || + 52488 == i || + 52516 == i || + 52544 == i || + 52572 == i || + 52600 == i || + 52628 == i || + 52656 == i || + 52684 == i || + 52712 == i || + 52740 == i || + 52768 == i || + 52796 == i || + 52824 == i || + 52852 == i || + 52880 == i || + 52908 == i || + 52936 == i || + 52964 == i || + 52992 == i || + 53020 == i || + 53048 == i || + 53076 == i || + 53104 == i || + 53132 == i || + 53160 == i || + 53188 == i || + 53216 == i || + 53244 == i || + 53272 == i || + 53300 == i || + 53328 == i || + 53356 == i || + 53384 == i || + 53412 == i || + 53440 == i || + 53468 == i || + 53496 == i || + 53524 == i || + 53552 == i || + 53580 == i || + 53608 == i || + 53636 == i || + 53664 == i || + 53692 == i || + 53720 == i || + 53748 == i || + 53776 == i || + 53804 == i || + 53832 == i || + 53860 == i || + 53888 == i || + 53916 == i || + 53944 == i || + 53972 == i || + 54e3 == i || + 54028 == i || + 54056 == i || + 54084 == i || + 54112 == i || + 54140 == i || + 54168 == i || + 54196 == i || + 54224 == i || + 54252 == i || + 54280 == i || + 54308 == i || + 54336 == i || + 54364 == i || + 54392 == i || + 54420 == i || + 54448 == i || + 54476 == i || + 54504 == i || + 54532 == i || + 54560 == i || + 54588 == i || + 54616 == i || + 54644 == i || + 54672 == i || + 54700 == i || + 54728 == i || + 54756 == i || + 54784 == i || + 54812 == i || + 54840 == i || + 54868 == i || + 54896 == i || + 54924 == i || + 54952 == i || + 54980 == i || + 55008 == i || + 55036 == i || + 55064 == i || + 55092 == i || + 55120 == i || + 55148 == i || + 55176 == i + ? 9 + : (44033 <= i && i <= 44059) || + (44061 <= i && i <= 44087) || + (44089 <= i && i <= 44115) || + (44117 <= i && i <= 44143) || + (44145 <= i && i <= 44171) || + (44173 <= i && i <= 44199) || + (44201 <= i && i <= 44227) || + (44229 <= i && i <= 44255) || + (44257 <= i && i <= 44283) || + (44285 <= i && i <= 44311) || + (44313 <= i && i <= 44339) || + (44341 <= i && i <= 44367) || + (44369 <= i && i <= 44395) || + (44397 <= i && i <= 44423) || + (44425 <= i && i <= 44451) || + (44453 <= i && i <= 44479) || + (44481 <= i && i <= 44507) || + (44509 <= i && i <= 44535) || + (44537 <= i && i <= 44563) || + (44565 <= i && i <= 44591) || + (44593 <= i && i <= 44619) || + (44621 <= i && i <= 44647) || + (44649 <= i && i <= 44675) || + (44677 <= i && i <= 44703) || + (44705 <= i && i <= 44731) || + (44733 <= i && i <= 44759) || + (44761 <= i && i <= 44787) || + (44789 <= i && i <= 44815) || + (44817 <= i && i <= 44843) || + (44845 <= i && i <= 44871) || + (44873 <= i && i <= 44899) || + (44901 <= i && i <= 44927) || + (44929 <= i && i <= 44955) || + (44957 <= i && i <= 44983) || + (44985 <= i && i <= 45011) || + (45013 <= i && i <= 45039) || + (45041 <= i && i <= 45067) || + (45069 <= i && i <= 45095) || + (45097 <= i && i <= 45123) || + (45125 <= i && i <= 45151) || + (45153 <= i && i <= 45179) || + (45181 <= i && i <= 45207) || + (45209 <= i && i <= 45235) || + (45237 <= i && i <= 45263) || + (45265 <= i && i <= 45291) || + (45293 <= i && i <= 45319) || + (45321 <= i && i <= 45347) || + (45349 <= i && i <= 45375) || + (45377 <= i && i <= 45403) || + (45405 <= i && i <= 45431) || + (45433 <= i && i <= 45459) || + (45461 <= i && i <= 45487) || + (45489 <= i && i <= 45515) || + (45517 <= i && i <= 45543) || + (45545 <= i && i <= 45571) || + (45573 <= i && i <= 45599) || + (45601 <= i && i <= 45627) || + (45629 <= i && i <= 45655) || + (45657 <= i && i <= 45683) || + (45685 <= i && i <= 45711) || + (45713 <= i && i <= 45739) || + (45741 <= i && i <= 45767) || + (45769 <= i && i <= 45795) || + (45797 <= i && i <= 45823) || + (45825 <= i && i <= 45851) || + (45853 <= i && i <= 45879) || + (45881 <= i && i <= 45907) || + (45909 <= i && i <= 45935) || + (45937 <= i && i <= 45963) || + (45965 <= i && i <= 45991) || + (45993 <= i && i <= 46019) || + (46021 <= i && i <= 46047) || + (46049 <= i && i <= 46075) || + (46077 <= i && i <= 46103) || + (46105 <= i && i <= 46131) || + (46133 <= i && i <= 46159) || + (46161 <= i && i <= 46187) || + (46189 <= i && i <= 46215) || + (46217 <= i && i <= 46243) || + (46245 <= i && i <= 46271) || + (46273 <= i && i <= 46299) || + (46301 <= i && i <= 46327) || + (46329 <= i && i <= 46355) || + (46357 <= i && i <= 46383) || + (46385 <= i && i <= 46411) || + (46413 <= i && i <= 46439) || + (46441 <= i && i <= 46467) || + (46469 <= i && i <= 46495) || + (46497 <= i && i <= 46523) || + (46525 <= i && i <= 46551) || + (46553 <= i && i <= 46579) || + (46581 <= i && i <= 46607) || + (46609 <= i && i <= 46635) || + (46637 <= i && i <= 46663) || + (46665 <= i && i <= 46691) || + (46693 <= i && i <= 46719) || + (46721 <= i && i <= 46747) || + (46749 <= i && i <= 46775) || + (46777 <= i && i <= 46803) || + (46805 <= i && i <= 46831) || + (46833 <= i && i <= 46859) || + (46861 <= i && i <= 46887) || + (46889 <= i && i <= 46915) || + (46917 <= i && i <= 46943) || + (46945 <= i && i <= 46971) || + (46973 <= i && i <= 46999) || + (47001 <= i && i <= 47027) || + (47029 <= i && i <= 47055) || + (47057 <= i && i <= 47083) || + (47085 <= i && i <= 47111) || + (47113 <= i && i <= 47139) || + (47141 <= i && i <= 47167) || + (47169 <= i && i <= 47195) || + (47197 <= i && i <= 47223) || + (47225 <= i && i <= 47251) || + (47253 <= i && i <= 47279) || + (47281 <= i && i <= 47307) || + (47309 <= i && i <= 47335) || + (47337 <= i && i <= 47363) || + (47365 <= i && i <= 47391) || + (47393 <= i && i <= 47419) || + (47421 <= i && i <= 47447) || + (47449 <= i && i <= 47475) || + (47477 <= i && i <= 47503) || + (47505 <= i && i <= 47531) || + (47533 <= i && i <= 47559) || + (47561 <= i && i <= 47587) || + (47589 <= i && i <= 47615) || + (47617 <= i && i <= 47643) || + (47645 <= i && i <= 47671) || + (47673 <= i && i <= 47699) || + (47701 <= i && i <= 47727) || + (47729 <= i && i <= 47755) || + (47757 <= i && i <= 47783) || + (47785 <= i && i <= 47811) || + (47813 <= i && i <= 47839) || + (47841 <= i && i <= 47867) || + (47869 <= i && i <= 47895) || + (47897 <= i && i <= 47923) || + (47925 <= i && i <= 47951) || + (47953 <= i && i <= 47979) || + (47981 <= i && i <= 48007) || + (48009 <= i && i <= 48035) || + (48037 <= i && i <= 48063) || + (48065 <= i && i <= 48091) || + (48093 <= i && i <= 48119) || + (48121 <= i && i <= 48147) || + (48149 <= i && i <= 48175) || + (48177 <= i && i <= 48203) || + (48205 <= i && i <= 48231) || + (48233 <= i && i <= 48259) || + (48261 <= i && i <= 48287) || + (48289 <= i && i <= 48315) || + (48317 <= i && i <= 48343) || + (48345 <= i && i <= 48371) || + (48373 <= i && i <= 48399) || + (48401 <= i && i <= 48427) || + (48429 <= i && i <= 48455) || + (48457 <= i && i <= 48483) || + (48485 <= i && i <= 48511) || + (48513 <= i && i <= 48539) || + (48541 <= i && i <= 48567) || + (48569 <= i && i <= 48595) || + (48597 <= i && i <= 48623) || + (48625 <= i && i <= 48651) || + (48653 <= i && i <= 48679) || + (48681 <= i && i <= 48707) || + (48709 <= i && i <= 48735) || + (48737 <= i && i <= 48763) || + (48765 <= i && i <= 48791) || + (48793 <= i && i <= 48819) || + (48821 <= i && i <= 48847) || + (48849 <= i && i <= 48875) || + (48877 <= i && i <= 48903) || + (48905 <= i && i <= 48931) || + (48933 <= i && i <= 48959) || + (48961 <= i && i <= 48987) || + (48989 <= i && i <= 49015) || + (49017 <= i && i <= 49043) || + (49045 <= i && i <= 49071) || + (49073 <= i && i <= 49099) || + (49101 <= i && i <= 49127) || + (49129 <= i && i <= 49155) || + (49157 <= i && i <= 49183) || + (49185 <= i && i <= 49211) || + (49213 <= i && i <= 49239) || + (49241 <= i && i <= 49267) || + (49269 <= i && i <= 49295) || + (49297 <= i && i <= 49323) || + (49325 <= i && i <= 49351) || + (49353 <= i && i <= 49379) || + (49381 <= i && i <= 49407) || + (49409 <= i && i <= 49435) || + (49437 <= i && i <= 49463) || + (49465 <= i && i <= 49491) || + (49493 <= i && i <= 49519) || + (49521 <= i && i <= 49547) || + (49549 <= i && i <= 49575) || + (49577 <= i && i <= 49603) || + (49605 <= i && i <= 49631) || + (49633 <= i && i <= 49659) || + (49661 <= i && i <= 49687) || + (49689 <= i && i <= 49715) || + (49717 <= i && i <= 49743) || + (49745 <= i && i <= 49771) || + (49773 <= i && i <= 49799) || + (49801 <= i && i <= 49827) || + (49829 <= i && i <= 49855) || + (49857 <= i && i <= 49883) || + (49885 <= i && i <= 49911) || + (49913 <= i && i <= 49939) || + (49941 <= i && i <= 49967) || + (49969 <= i && i <= 49995) || + (49997 <= i && i <= 50023) || + (50025 <= i && i <= 50051) || + (50053 <= i && i <= 50079) || + (50081 <= i && i <= 50107) || + (50109 <= i && i <= 50135) || + (50137 <= i && i <= 50163) || + (50165 <= i && i <= 50191) || + (50193 <= i && i <= 50219) || + (50221 <= i && i <= 50247) || + (50249 <= i && i <= 50275) || + (50277 <= i && i <= 50303) || + (50305 <= i && i <= 50331) || + (50333 <= i && i <= 50359) || + (50361 <= i && i <= 50387) || + (50389 <= i && i <= 50415) || + (50417 <= i && i <= 50443) || + (50445 <= i && i <= 50471) || + (50473 <= i && i <= 50499) || + (50501 <= i && i <= 50527) || + (50529 <= i && i <= 50555) || + (50557 <= i && i <= 50583) || + (50585 <= i && i <= 50611) || + (50613 <= i && i <= 50639) || + (50641 <= i && i <= 50667) || + (50669 <= i && i <= 50695) || + (50697 <= i && i <= 50723) || + (50725 <= i && i <= 50751) || + (50753 <= i && i <= 50779) || + (50781 <= i && i <= 50807) || + (50809 <= i && i <= 50835) || + (50837 <= i && i <= 50863) || + (50865 <= i && i <= 50891) || + (50893 <= i && i <= 50919) || + (50921 <= i && i <= 50947) || + (50949 <= i && i <= 50975) || + (50977 <= i && i <= 51003) || + (51005 <= i && i <= 51031) || + (51033 <= i && i <= 51059) || + (51061 <= i && i <= 51087) || + (51089 <= i && i <= 51115) || + (51117 <= i && i <= 51143) || + (51145 <= i && i <= 51171) || + (51173 <= i && i <= 51199) || + (51201 <= i && i <= 51227) || + (51229 <= i && i <= 51255) || + (51257 <= i && i <= 51283) || + (51285 <= i && i <= 51311) || + (51313 <= i && i <= 51339) || + (51341 <= i && i <= 51367) || + (51369 <= i && i <= 51395) || + (51397 <= i && i <= 51423) || + (51425 <= i && i <= 51451) || + (51453 <= i && i <= 51479) || + (51481 <= i && i <= 51507) || + (51509 <= i && i <= 51535) || + (51537 <= i && i <= 51563) || + (51565 <= i && i <= 51591) || + (51593 <= i && i <= 51619) || + (51621 <= i && i <= 51647) || + (51649 <= i && i <= 51675) || + (51677 <= i && i <= 51703) || + (51705 <= i && i <= 51731) || + (51733 <= i && i <= 51759) || + (51761 <= i && i <= 51787) || + (51789 <= i && i <= 51815) || + (51817 <= i && i <= 51843) || + (51845 <= i && i <= 51871) || + (51873 <= i && i <= 51899) || + (51901 <= i && i <= 51927) || + (51929 <= i && i <= 51955) || + (51957 <= i && i <= 51983) || + (51985 <= i && i <= 52011) || + (52013 <= i && i <= 52039) || + (52041 <= i && i <= 52067) || + (52069 <= i && i <= 52095) || + (52097 <= i && i <= 52123) || + (52125 <= i && i <= 52151) || + (52153 <= i && i <= 52179) || + (52181 <= i && i <= 52207) || + (52209 <= i && i <= 52235) || + (52237 <= i && i <= 52263) || + (52265 <= i && i <= 52291) || + (52293 <= i && i <= 52319) || + (52321 <= i && i <= 52347) || + (52349 <= i && i <= 52375) || + (52377 <= i && i <= 52403) || + (52405 <= i && i <= 52431) || + (52433 <= i && i <= 52459) || + (52461 <= i && i <= 52487) || + (52489 <= i && i <= 52515) || + (52517 <= i && i <= 52543) || + (52545 <= i && i <= 52571) || + (52573 <= i && i <= 52599) || + (52601 <= i && i <= 52627) || + (52629 <= i && i <= 52655) || + (52657 <= i && i <= 52683) || + (52685 <= i && i <= 52711) || + (52713 <= i && i <= 52739) || + (52741 <= i && i <= 52767) || + (52769 <= i && i <= 52795) || + (52797 <= i && i <= 52823) || + (52825 <= i && i <= 52851) || + (52853 <= i && i <= 52879) || + (52881 <= i && i <= 52907) || + (52909 <= i && i <= 52935) || + (52937 <= i && i <= 52963) || + (52965 <= i && i <= 52991) || + (52993 <= i && i <= 53019) || + (53021 <= i && i <= 53047) || + (53049 <= i && i <= 53075) || + (53077 <= i && i <= 53103) || + (53105 <= i && i <= 53131) || + (53133 <= i && i <= 53159) || + (53161 <= i && i <= 53187) || + (53189 <= i && i <= 53215) || + (53217 <= i && i <= 53243) || + (53245 <= i && i <= 53271) || + (53273 <= i && i <= 53299) || + (53301 <= i && i <= 53327) || + (53329 <= i && i <= 53355) || + (53357 <= i && i <= 53383) || + (53385 <= i && i <= 53411) || + (53413 <= i && i <= 53439) || + (53441 <= i && i <= 53467) || + (53469 <= i && i <= 53495) || + (53497 <= i && i <= 53523) || + (53525 <= i && i <= 53551) || + (53553 <= i && i <= 53579) || + (53581 <= i && i <= 53607) || + (53609 <= i && i <= 53635) || + (53637 <= i && i <= 53663) || + (53665 <= i && i <= 53691) || + (53693 <= i && i <= 53719) || + (53721 <= i && i <= 53747) || + (53749 <= i && i <= 53775) || + (53777 <= i && i <= 53803) || + (53805 <= i && i <= 53831) || + (53833 <= i && i <= 53859) || + (53861 <= i && i <= 53887) || + (53889 <= i && i <= 53915) || + (53917 <= i && i <= 53943) || + (53945 <= i && i <= 53971) || + (53973 <= i && i <= 53999) || + (54001 <= i && i <= 54027) || + (54029 <= i && i <= 54055) || + (54057 <= i && i <= 54083) || + (54085 <= i && i <= 54111) || + (54113 <= i && i <= 54139) || + (54141 <= i && i <= 54167) || + (54169 <= i && i <= 54195) || + (54197 <= i && i <= 54223) || + (54225 <= i && i <= 54251) || + (54253 <= i && i <= 54279) || + (54281 <= i && i <= 54307) || + (54309 <= i && i <= 54335) || + (54337 <= i && i <= 54363) || + (54365 <= i && i <= 54391) || + (54393 <= i && i <= 54419) || + (54421 <= i && i <= 54447) || + (54449 <= i && i <= 54475) || + (54477 <= i && i <= 54503) || + (54505 <= i && i <= 54531) || + (54533 <= i && i <= 54559) || + (54561 <= i && i <= 54587) || + (54589 <= i && i <= 54615) || + (54617 <= i && i <= 54643) || + (54645 <= i && i <= 54671) || + (54673 <= i && i <= 54699) || + (54701 <= i && i <= 54727) || + (54729 <= i && i <= 54755) || + (54757 <= i && i <= 54783) || + (54785 <= i && i <= 54811) || + (54813 <= i && i <= 54839) || + (54841 <= i && i <= 54867) || + (54869 <= i && i <= 54895) || + (54897 <= i && i <= 54923) || + (54925 <= i && i <= 54951) || + (54953 <= i && i <= 54979) || + (54981 <= i && i <= 55007) || + (55009 <= i && i <= 55035) || + (55037 <= i && i <= 55063) || + (55065 <= i && i <= 55091) || + (55093 <= i && i <= 55119) || + (55121 <= i && i <= 55147) || + (55149 <= i && i <= 55175) || + (55177 <= i && i <= 55203) + ? 10 + : 9757 == i || + 9977 == i || + (9994 <= i && i <= 9997) || + 127877 == i || + (127938 <= i && i <= 127940) || + 127943 == i || + (127946 <= i && i <= 127948) || + (128066 <= i && i <= 128067) || + (128070 <= i && i <= 128080) || + 128110 == i || + (128112 <= i && i <= 128120) || + 128124 == i || + (128129 <= i && i <= 128131) || + (128133 <= i && i <= 128135) || + 128170 == i || + (128372 <= i && i <= 128373) || + 128378 == i || + 128400 == i || + (128405 <= i && i <= 128406) || + (128581 <= i && i <= 128583) || + (128587 <= i && i <= 128591) || + 128675 == i || + (128692 <= i && i <= 128694) || + 128704 == i || + 128716 == i || + (129304 <= i && i <= 129308) || + (129310 <= i && i <= 129311) || + 129318 == i || + (129328 <= i && i <= 129337) || + (129341 <= i && i <= 129342) || + (129489 <= i && i <= 129501) + ? A + : 127995 <= i && i <= 127999 + ? 14 + : 8205 == i + ? 15 + : 9792 == i || + 9794 == i || + (9877 <= i && i <= 9878) || + 9992 == i || + 10084 == i || + 127752 == i || + 127806 == i || + 127859 == i || + 127891 == i || + 127908 == i || + 127912 == i || + 127979 == i || + 127981 == i || + 128139 == i || + (128187 <= i && i <= 128188) || + 128295 == i || + 128300 == i || + 128488 == i || + 128640 == i || + 128658 == i + ? n + : 128102 <= i && i <= 128105 + ? o + : 11; + } + return ( + (this.nextBreak = function (e, t) { + if ((void 0 === t && (t = 0), t < 0)) return 0; + if (t >= e.length - 1) return e.length; + for ( + var r, A, n = a(i(e, t)), o = [], c = t + 1; + c < e.length; + c++ + ) + if ( + ((A = c - 1), + !( + 55296 <= (r = e).charCodeAt(A) && + r.charCodeAt(A) <= 56319 && + 56320 <= r.charCodeAt(A + 1) && + r.charCodeAt(A + 1) <= 57343 + )) + ) { + var g = a(i(e, c)); + if (s(n, o, g)) return c; + o.push(g); + } + return e.length; + }), + (this.splitGraphemes = function (e) { + for ( + var t, r = [], A = 0; + (t = this.nextBreak(e, A)) < e.length; + + ) + r.push(e.slice(A, t)), (A = t); + return A < e.length && r.push(e.slice(A)), r; + }), + (this.iterateGraphemes = function (e) { + var t = 0, + r = { + next: function () { + var r, A; + return (A = this.nextBreak(e, t)) < e.length + ? ((r = e.slice(t, A)), (t = A), { value: r, done: !1 }) + : t < e.length + ? ((r = e.slice(t)), + (t = e.length), + { value: r, done: !1 }) + : { value: void 0, done: !0 }; + }.bind(this), + }; + return ( + 'undefined' != typeof Symbol && + Symbol.iterator && + (r[Symbol.iterator] = function () { + return r; + }), + r + ); + }), + (this.countGraphemes = function (e) { + for ( + var t, r = 0, A = 0; + (t = this.nextBreak(e, A)) < e.length; + + ) + (A = t), r++; + return A < e.length && r++, r; + }), + this + ); + }); + }, + 72918: (e) => { + 'use strict'; + e.exports = (e, t = process.argv) => { + const r = e.startsWith('-') ? '' : 1 === e.length ? '-' : '--', + A = t.indexOf(r + e), + n = t.indexOf('--'); + return -1 !== A && (-1 === n || A < n); + }; + }, + 86834: (e) => { + 'use strict'; + const t = [200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501], + r = [ + 200, + 203, + 204, + 300, + 301, + 302, + 303, + 307, + 308, + 404, + 405, + 410, + 414, + 501, + ], + A = { + date: !0, + connection: !0, + 'keep-alive': !0, + 'proxy-authenticate': !0, + 'proxy-authorization': !0, + te: !0, + trailer: !0, + 'transfer-encoding': !0, + upgrade: !0, + }, + n = { + 'content-length': !0, + 'content-encoding': !0, + 'transfer-encoding': !0, + 'content-range': !0, + }; + function o(e) { + const t = {}; + if (!e) return t; + const r = e.trim().split(/\s*,\s*/); + for (const e of r) { + const [r, A] = e.split(/\s*=\s*/, 2); + t[r] = void 0 === A || A.replace(/^"|"$/g, ''); + } + return t; + } + function i(e) { + let t = []; + for (const r in e) { + const A = e[r]; + t.push(!0 === A ? r : r + '=' + A); + } + if (t.length) return t.join(', '); + } + e.exports = class { + constructor( + e, + t, + { + shared: r, + cacheHeuristic: A, + immutableMinTimeToLive: n, + ignoreCargoCult: s, + trustServerDate: a, + _fromObject: c, + } = {} + ) { + if (c) this._fromObject(c); + else { + if (!t || !t.headers) throw Error('Response headers missing'); + this._assertRequestHasHeaders(e), + (this._responseTime = this.now()), + (this._isShared = !1 !== r), + (this._trustServerDate = void 0 === a || a), + (this._cacheHeuristic = void 0 !== A ? A : 0.1), + (this._immutableMinTtl = void 0 !== n ? n : 864e5), + (this._status = 'status' in t ? t.status : 200), + (this._resHeaders = t.headers), + (this._rescc = o(t.headers['cache-control'])), + (this._method = 'method' in e ? e.method : 'GET'), + (this._url = e.url), + (this._host = e.headers.host), + (this._noAuthorization = !e.headers.authorization), + (this._reqHeaders = t.headers.vary ? e.headers : null), + (this._reqcc = o(e.headers['cache-control'])), + s && + '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': i(this._rescc), + })), + delete this._resHeaders.expires, + delete this._resHeaders.pragma), + !t.headers['cache-control'] && + /no-cache/.test(t.headers.pragma) && + (this._rescc['no-cache'] = !0); + } + } + now() { + return Date.now(); + } + storable() { + return !( + this._reqcc['no-store'] || + !( + 'GET' === this._method || + 'HEAD' === this._method || + ('POST' === this._method && this._hasExplicitExpiration()) + ) || + -1 === r.indexOf(this._status) || + this._rescc['no-store'] || + (this._isShared && this._rescc.private) || + (this._isShared && + !this._noAuthorization && + !this._allowsStoringAuthenticated()) || + !( + this._resHeaders.expires || + this._rescc.public || + this._rescc['max-age'] || + this._rescc['s-maxage'] || + -1 !== t.indexOf(this._status) + ) + ); + } + _hasExplicitExpiration() { + return ( + (this._isShared && this._rescc['s-maxage']) || + this._rescc['max-age'] || + this._resHeaders.expires + ); + } + _assertRequestHasHeaders(e) { + if (!e || !e.headers) throw Error('Request headers missing'); + } + satisfiesWithoutRevalidation(e) { + this._assertRequestHasHeaders(e); + const t = o(e.headers['cache-control']); + if (t['no-cache'] || /no-cache/.test(e.headers.pragma)) return !1; + if (t['max-age'] && this.age() > t['max-age']) return !1; + if (t['min-fresh'] && this.timeToLive() < 1e3 * t['min-fresh']) + return !1; + if (this.stale()) { + if ( + !( + t['max-stale'] && + !this._rescc['must-revalidate'] && + (!0 === t['max-stale'] || + t['max-stale'] > this.age() - this.maxAge()) + ) + ) + return !1; + } + return this._requestMatches(e, !1); + } + _requestMatches(e, t) { + return ( + (!this._url || this._url === e.url) && + this._host === e.headers.host && + (!e.method || + this._method === e.method || + (t && 'HEAD' === e.method)) && + this._varyMatches(e) + ); + } + _allowsStoringAuthenticated() { + return ( + this._rescc['must-revalidate'] || + this._rescc.public || + this._rescc['s-maxage'] + ); + } + _varyMatches(e) { + if (!this._resHeaders.vary) return !0; + if ('*' === this._resHeaders.vary) return !1; + const t = this._resHeaders.vary + .trim() + .toLowerCase() + .split(/\s*,\s*/); + for (const r of t) + if (e.headers[r] !== this._reqHeaders[r]) return !1; + return !0; + } + _copyWithoutHopByHopHeaders(e) { + const t = {}; + for (const r in e) A[r] || (t[r] = e[r]); + if (e.connection) { + const r = e.connection.trim().split(/\s*,\s*/); + for (const e of r) delete t[e]; + } + if (t.warning) { + const e = t.warning + .split(/,/) + .filter((e) => !/^\s*1[0-9][0-9]/.test(e)); + e.length ? (t.warning = e.join(',').trim()) : delete t.warning; + } + return t; + } + responseHeaders() { + const e = this._copyWithoutHopByHopHeaders(this._resHeaders), + t = this.age(); + return ( + t > 86400 && + !this._hasExplicitExpiration() && + this.maxAge() > 86400 && + (e.warning = + (e.warning ? e.warning + ', ' : '') + + '113 - "rfc7234 5.5.4"'), + (e.age = '' + Math.round(t)), + (e.date = new Date(this.now()).toUTCString()), + e + ); + } + date() { + return this._trustServerDate + ? this._serverDate() + : this._responseTime; + } + _serverDate() { + const e = Date.parse(this._resHeaders.date); + if (isFinite(e)) { + const t = 288e5; + if (Math.abs(this._responseTime - e) < t) return e; + } + return this._responseTime; + } + age() { + let e = Math.max(0, (this._responseTime - this.date()) / 1e3); + if (this._resHeaders.age) { + let t = this._ageValue(); + t > e && (e = t); + } + return e + (this.now() - this._responseTime) / 1e3; + } + _ageValue() { + const e = parseInt(this._resHeaders.age); + return isFinite(e) ? e : 0; + } + maxAge() { + if (!this.storable() || this._rescc['no-cache']) return 0; + 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 (this._rescc['s-maxage']) + return parseInt(this._rescc['s-maxage'], 10); + } + if (this._rescc['max-age']) + return parseInt(this._rescc['max-age'], 10); + const e = this._rescc.immutable ? this._immutableMinTtl : 0, + t = this._serverDate(); + if (this._resHeaders.expires) { + const r = Date.parse(this._resHeaders.expires); + return Number.isNaN(r) || r < t ? 0 : Math.max(e, (r - t) / 1e3); + } + if (this._resHeaders['last-modified']) { + const r = Date.parse(this._resHeaders['last-modified']); + if (isFinite(r) && t > r) + return Math.max(e, ((t - r) / 1e3) * this._cacheHeuristic); + } + return e; + } + timeToLive() { + return 1e3 * Math.max(0, this.maxAge() - this.age()); + } + stale() { + return this.maxAge() <= this.age(); + } + static fromObject(e) { + return new this(void 0, void 0, { _fromObject: e }); + } + _fromObject(e) { + if (this._responseTime) throw Error('Reinitialized'); + if (!e || 1 !== e.v) throw Error('Invalid serialization'); + (this._responseTime = e.t), + (this._isShared = e.sh), + (this._cacheHeuristic = e.ch), + (this._immutableMinTtl = void 0 !== e.imm ? e.imm : 864e5), + (this._status = e.st), + (this._resHeaders = e.resh), + (this._rescc = e.rescc), + (this._method = e.m), + (this._url = e.u), + (this._host = e.h), + (this._noAuthorization = e.a), + (this._reqHeaders = e.reqh), + (this._reqcc = e.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, + }; + } + revalidationHeaders(e) { + this._assertRequestHasHeaders(e); + const t = this._copyWithoutHopByHopHeaders(e.headers); + if ( + (delete t['if-range'], + !this._requestMatches(e, !0) || !this.storable()) + ) + return ( + delete t['if-none-match'], delete t['if-modified-since'], t + ); + this._resHeaders.etag && + (t['if-none-match'] = t['if-none-match'] + ? `${t['if-none-match']}, ${this._resHeaders.etag}` + : this._resHeaders.etag); + if ( + t['accept-ranges'] || + t['if-match'] || + t['if-unmodified-since'] || + (this._method && 'GET' != this._method) + ) { + if ((delete t['if-modified-since'], t['if-none-match'])) { + const e = t['if-none-match'] + .split(/,/) + .filter((e) => !/^\s*W\//.test(e)); + e.length + ? (t['if-none-match'] = e.join(',').trim()) + : delete t['if-none-match']; + } + } else + this._resHeaders['last-modified'] && + !t['if-modified-since'] && + (t['if-modified-since'] = this._resHeaders['last-modified']); + return t; + } + revalidatedPolicy(e, t) { + if ((this._assertRequestHasHeaders(e), !t || !t.headers)) + throw Error('Response headers missing'); + let r = !1; + if ( + (void 0 !== t.status && 304 != t.status + ? (r = !1) + : t.headers.etag && !/^\s*W\//.test(t.headers.etag) + ? (r = + this._resHeaders.etag && + this._resHeaders.etag.replace(/^\s*W\//, '') === + t.headers.etag) + : this._resHeaders.etag && t.headers.etag + ? (r = + this._resHeaders.etag.replace(/^\s*W\//, '') === + t.headers.etag.replace(/^\s*W\//, '')) + : this._resHeaders['last-modified'] + ? (r = + this._resHeaders['last-modified'] === + t.headers['last-modified']) + : this._resHeaders.etag || + this._resHeaders['last-modified'] || + t.headers.etag || + t.headers['last-modified'] || + (r = !0), + !r) + ) + return { + policy: new this.constructor(e, t), + modified: 304 != t.status, + matches: !1, + }; + const A = {}; + for (const e in this._resHeaders) + A[e] = + e in t.headers && !n[e] ? t.headers[e] : this._resHeaders[e]; + const o = Object.assign({}, t, { + status: this._status, + method: this._method, + headers: A, + }); + return { + policy: new this.constructor(e, o, { + shared: this._isShared, + cacheHeuristic: this._cacheHeuristic, + immutableMinTimeToLive: this._immutableMinTtl, + trustServerDate: this._trustServerDate, + }), + modified: !1, + matches: !0, + }; + } + }; + }, + 94935: (e, t, r) => { + 'use strict'; + const A = r(28614), + n = r(4016), + o = r(97565), + i = r(49601), + s = Symbol('currentStreamsCount'), + a = Symbol('request'), + c = Symbol('cachedOriginSet'), + g = Symbol('gracefullyClosing'), + l = [ + 'maxDeflateDynamicTableSize', + 'maxSessionMemory', + 'maxHeaderListPairs', + 'maxOutstandingPings', + 'maxReservedRemoteStreams', + 'maxSendHeaderBlockLength', + 'paddingStrategy', + 'localAddress', + 'path', + 'rejectUnauthorized', + 'minDHSize', + 'ca', + 'cert', + 'clientCertEngine', + 'ciphers', + 'key', + 'pfx', + 'servername', + 'minVersion', + 'maxVersion', + 'secureProtocol', + 'crl', + 'honorCipherOrder', + 'ecdhCurve', + 'dhparam', + 'secureOptions', + 'sessionIdContext', + ], + u = (e, t) => + e.remoteSettings.maxConcurrentStreams > + t.remoteSettings.maxConcurrentStreams, + h = (e, t) => { + for (const r of e) + r[c].length < t[c].length && + r[c].every((e) => t[c].includes(e)) && + r[s] + t[s] <= t.remoteSettings.maxConcurrentStreams && + d(r); + }, + p = ({ agent: e, isFree: t }) => { + const r = {}; + for (const A in e.sessions) { + const n = e.sessions[A].filter((e) => { + const r = + e[C.kCurrentStreamsCount] < + e.remoteSettings.maxConcurrentStreams; + return t ? r : !r; + }); + 0 !== n.length && (r[A] = n); + } + return r; + }, + d = (e) => { + (e[g] = !0), 0 === e[s] && e.close(); + }; + class C extends A { + constructor({ + timeout: e = 6e4, + maxSessions: t = 1 / 0, + maxFreeSessions: r = 10, + maxCachedTlsSessions: A = 100, + } = {}) { + super(), + (this.sessions = {}), + (this.queue = {}), + (this.timeout = e), + (this.maxSessions = t), + (this.maxFreeSessions = r), + (this._freeSessionsCount = 0), + (this._sessionsCount = 0), + (this.settings = { enablePush: !1 }), + (this.tlsSessionCache = new i({ maxSize: A })); + } + static normalizeOrigin(e, t) { + return ( + 'string' == typeof e && (e = new URL(e)), + t && e.hostname !== t && (e.hostname = t), + e.origin + ); + } + normalizeOptions(e) { + let t = ''; + if (e) for (const r of l) e[r] && (t += ':' + e[r]); + return t; + } + _tryToCreateNewSession(e, t) { + if (!(e in this.queue) || !(t in this.queue[e])) return; + const r = this.queue[e][t]; + this._sessionsCount < this.maxSessions && + !r.completed && + ((r.completed = !0), r()); + } + getSession(e, t, r) { + return new Promise((A, n) => { + Array.isArray(r) + ? ((r = [...r]), A()) + : (r = [{ resolve: A, reject: n }]); + const i = this.normalizeOptions(t), + l = C.normalizeOrigin(e, t && t.servername); + if (void 0 === l) { + for (const { reject: e } of r) + e( + new TypeError( + 'The `origin` argument needs to be a string or an URL object' + ) + ); + return; + } + if (i in this.sessions) { + const e = this.sessions[i]; + let t, + A = -1, + n = -1; + for (const r of e) { + const e = r.remoteSettings.maxConcurrentStreams; + if (e < A) break; + if (r[c].includes(l)) { + const o = r[s]; + if (o >= e || r[g] || r.destroyed) continue; + t || (A = e), o > n && ((t = r), (n = o)); + } + } + if (t) { + if (1 !== r.length) { + for (const { reject: e } of r) { + e( + new Error( + `Expected the length of listeners to be 1, got ${r.length}.\nPlease report this to https://github.com/szmarczak/http2-wrapper/` + ) + ); + } + return; + } + return void r[0].resolve(t); + } + } + if (i in this.queue) { + if (l in this.queue[i]) + return ( + this.queue[i][l].listeners.push(...r), + void this._tryToCreateNewSession(i, l) + ); + } else this.queue[i] = {}; + const p = () => { + i in this.queue && + this.queue[i][l] === f && + (delete this.queue[i][l], + 0 === Object.keys(this.queue[i]).length && + delete this.queue[i]); + }, + f = () => { + const A = `${l}:${i}`; + let n = !1; + try { + const C = o.connect(e, { + createConnection: this.createConnection, + settings: this.settings, + session: this.tlsSessionCache.get(A), + ...t, + }); + (C[s] = 0), (C[g] = !1); + const I = () => + C[s] < C.remoteSettings.maxConcurrentStreams; + let E = !0; + C.socket.once('session', (e) => { + this.tlsSessionCache.set(A, e); + }), + C.once('error', (e) => { + for (const { reject: t } of r) t(e); + this.tlsSessionCache.delete(A); + }), + C.setTimeout(this.timeout, () => { + C.destroy(); + }), + C.once('close', () => { + if (n) { + E && this._freeSessionsCount--, this._sessionsCount--; + const e = this.sessions[i]; + e.splice(e.indexOf(C), 1), + 0 === e.length && delete this.sessions[i]; + } else { + const e = new Error( + 'Session closed without receiving a SETTINGS frame' + ); + e.code = 'HTTP2WRAPPER_NOSETTINGS'; + for (const { reject: t } of r) t(e); + p(); + } + this._tryToCreateNewSession(i, l); + }); + const B = () => { + if (i in this.queue && I()) + for (const e of C[c]) + if (e in this.queue[i]) { + const { listeners: t } = this.queue[i][e]; + for (; 0 !== t.length && I(); ) + t.shift().resolve(C); + const r = this.queue[i]; + if ( + 0 === r[e].listeners.length && + (delete r[e], 0 === Object.keys(r).length) + ) { + delete this.queue[i]; + break; + } + if (!I()) break; + } + }; + C.on('origin', () => { + (C[c] = C.originSet), + I() && (B(), h(this.sessions[i], C)); + }), + C.once('remoteSettings', () => { + if ( + (C.ref(), + C.unref(), + this._sessionsCount++, + f.destroyed) + ) { + const e = new Error('Agent has been destroyed'); + for (const t of r) t.reject(e); + C.destroy(); + } else { + C[c] = C.originSet; + { + const e = this.sessions; + if (i in e) { + const t = e[i]; + t.splice( + ((e, t, r) => { + let A = 0, + n = e.length; + for (; A < n; ) { + const o = (A + n) >>> 1; + r(e[o], t) ? (A = o + 1) : (n = o); + } + return A; + })(t, C, u), + 0, + C + ); + } else e[i] = [C]; + } + (this._freeSessionsCount += 1), + (n = !0), + this.emit('session', C), + B(), + p(), + 0 === C[s] && + this._freeSessionsCount > this.maxFreeSessions && + C.close(), + 0 !== r.length && + (this.getSession(l, t, r), (r.length = 0)), + C.on('remoteSettings', () => { + B(), h(this.sessions[i], C); + }); + } + }), + (C[a] = C.request), + (C.request = (e, t) => { + if (C[g]) + throw new Error( + 'The session is gracefully closing. No new streams are allowed.' + ); + const r = C[a](e, t); + return ( + C.ref(), + ++C[s], + C[s] === C.remoteSettings.maxConcurrentStreams && + this._freeSessionsCount--, + r.once('close', () => { + if ( + ((E = I()), + --C[s], + !C.destroyed && + !C.closed && + (((e, t) => { + for (const r of e) + t[c].length < r[c].length && + t[c].every((e) => r[c].includes(e)) && + t[s] + r[s] <= + r.remoteSettings.maxConcurrentStreams && + d(t); + })(this.sessions[i], C), + I() && !C.closed)) + ) { + E || (this._freeSessionsCount++, (E = !0)); + const e = 0 === C[s]; + e && C.unref(), + e && + (this._freeSessionsCount > + this.maxFreeSessions || + C[g]) + ? C.close() + : (h(this.sessions[i], C), B()); + } + }), + r + ); + }); + } catch (e) { + for (const t of r) t.reject(e); + p(); + } + }; + (f.listeners = r), + (f.completed = !1), + (f.destroyed = !1), + (this.queue[i][l] = f), + this._tryToCreateNewSession(i, l); + }); + } + request(e, t, r, A) { + return new Promise((n, o) => { + this.getSession(e, t, [ + { + reject: o, + resolve: (e) => { + try { + n(e.request(r, A)); + } catch (e) { + o(e); + } + }, + }, + ]); + }); + } + createConnection(e, t) { + return C.connect(e, t); + } + static connect(e, t) { + t.ALPNProtocols = ['h2']; + const r = e.port || 443, + A = e.hostname || e.host; + return ( + void 0 === t.servername && (t.servername = A), n.connect(r, A, t) + ); + } + closeFreeSessions() { + for (const e of Object.values(this.sessions)) + for (const t of e) 0 === t[s] && t.close(); + } + destroy(e) { + for (const t of Object.values(this.sessions)) + for (const r of t) r.destroy(e); + for (const e of Object.values(this.queue)) + for (const t of Object.values(e)) t.destroyed = !0; + this.queue = {}; + } + get freeSessions() { + return p({ agent: this, isFree: !0 }); + } + get busySessions() { + return p({ agent: this, isFree: !1 }); + } + } + (C.kCurrentStreamsCount = s), + (C.kGracefullyClosing = g), + (e.exports = { Agent: C, globalAgent: new C() }); + }, + 2398: (e, t, r) => { + 'use strict'; + const A = r(98605), + n = r(57211), + o = r(19476), + i = r(49601), + s = r(33134), + a = r(5209), + c = r(50075), + g = new i({ maxSize: 100 }), + l = new Map(), + u = (e, t, r) => { + t._httpMessage = { shouldKeepAlive: !0 }; + const A = () => { + e.emit('free', t, r); + }; + t.on('free', A); + const n = () => { + e.removeSocket(t, r); + }; + t.on('close', n); + const o = () => { + e.removeSocket(t, r), + t.off('close', n), + t.off('free', A), + t.off('agentRemove', o); + }; + t.on('agentRemove', o), e.emit('free', t, r); + }; + (e.exports = async (e, t, r) => { + if ( + (('string' == typeof e || e instanceof URL) && (e = c(new URL(e))), + 'function' == typeof t && ((r = t), (t = void 0)), + (t = { + ALPNProtocols: ['h2', 'http/1.1'], + ...e, + ...t, + resolveSocket: !0, + }), + !Array.isArray(t.ALPNProtocols) || 0 === t.ALPNProtocols.length) + ) + throw new Error( + 'The `ALPNProtocols` option must be an Array with at least one entry' + ); + t.protocol = t.protocol || 'https:'; + const i = 'https:' === t.protocol; + (t.host = t.hostname || t.host || 'localhost'), + (t.session = t.tlsSession), + (t.servername = t.servername || a(t)), + (t.port = t.port || (i ? 443 : 80)), + (t._defaultAgent = i ? n.globalAgent : A.globalAgent); + const h = t.agent; + if (h) { + if (h.addRequest) + throw new Error( + 'The `options.agent` object can contain only `http`, `https` or `http2` properties' + ); + t.agent = h[i ? 'https' : 'http']; + } + if (i) { + if ( + 'h2' === + (await (async (e) => { + const t = `${e.host}:${e.port}:${e.ALPNProtocols.sort()}`; + if (!g.has(t)) { + if (l.has(t)) { + return (await l.get(t)).alpnProtocol; + } + const { path: r, agent: A } = e; + e.path = e.socketPath; + const i = o(e); + l.set(t, i); + try { + const { socket: o, alpnProtocol: s } = await i; + if ((g.set(t, s), (e.path = r), 'h2' === s)) o.destroy(); + else { + const { globalAgent: t } = n, + r = n.Agent.prototype.createConnection; + A + ? A.createConnection === r + ? u(A, o, e) + : o.destroy() + : t.createConnection === r + ? u(t, o, e) + : o.destroy(); + } + return l.delete(t), s; + } catch (e) { + throw (l.delete(t), e); + } + } + return g.get(t); + })(t)) + ) + return h && (t.agent = h.http2), new s(t, r); + } + return A.request(t, r); + }), + (e.exports.protocolCache = g); + }, + 33134: (e, t, r) => { + 'use strict'; + const A = r(97565), + { Writable: n } = r(92413), + { Agent: o, globalAgent: i } = r(94935), + s = r(53433), + a = r(50075), + c = r(66192), + g = r(50978), + { + ERR_INVALID_ARG_TYPE: l, + ERR_INVALID_PROTOCOL: u, + ERR_HTTP_HEADERS_SENT: h, + ERR_INVALID_HTTP_TOKEN: p, + ERR_HTTP_INVALID_HEADER_VALUE: d, + ERR_INVALID_CHAR: C, + } = r(64080), + { + HTTP2_HEADER_STATUS: f, + HTTP2_HEADER_METHOD: I, + HTTP2_HEADER_PATH: E, + HTTP2_METHOD_CONNECT: B, + } = A.constants, + y = Symbol('headers'), + m = Symbol('origin'), + w = Symbol('session'), + Q = Symbol('options'), + D = Symbol('flushedHeaders'), + b = Symbol('jobs'), + v = /^[\^`\-\w!#$%&*+.|~]+$/, + S = /[^\t\u0020-\u007E\u0080-\u00FF]/; + e.exports = class extends n { + constructor(e, t, r) { + super({ autoDestroy: !1 }); + const A = 'string' == typeof e || e instanceof URL; + if ( + (A && (e = a(e instanceof URL ? e : new URL(e))), + 'function' == typeof t || void 0 === t + ? ((r = t), (t = A ? e : { ...e })) + : (t = { ...e, ...t }), + t.h2session) + ) + this[w] = t.h2session; + else if (!1 === t.agent) this.agent = new o({ maxFreeSessions: 0 }); + else if (void 0 === t.agent || null === t.agent) + 'function' == typeof t.createConnection + ? ((this.agent = new o({ maxFreeSessions: 0 })), + (this.agent.createConnection = t.createConnection)) + : (this.agent = i); + else { + if ('function' != typeof t.agent.request) + throw new l( + 'options.agent', + ['Agent-like Object', 'undefined', 'false'], + t.agent + ); + this.agent = t.agent; + } + if (t.protocol && 'https:' !== t.protocol) + throw new u(t.protocol, 'https:'); + const n = + t.port || + t.defaultPort || + (this.agent && this.agent.defaultPort) || + 443, + s = t.hostname || t.host || 'localhost'; + delete t.hostname, delete t.host, delete t.port; + const { timeout: c } = t; + if ( + ((t.timeout = void 0), + (this[y] = Object.create(null)), + (this[b] = []), + (this.socket = null), + (this.connection = null), + (this.method = t.method || 'GET'), + (this.path = t.path), + (this.res = null), + (this.aborted = !1), + (this.reusedSocket = !1), + t.headers) + ) + for (const [e, r] of Object.entries(t.headers)) + this.setHeader(e, r); + t.auth && + !('authorization' in this[y]) && + (this[y].authorization = + 'Basic ' + Buffer.from(t.auth).toString('base64')), + (t.session = t.tlsSession), + (t.path = t.socketPath), + (this[Q] = t), + 443 === n + ? ((this[m] = 'https://' + s), + ':authority' in this[y] || (this[y][':authority'] = s)) + : ((this[m] = `https://${s}:${n}`), + ':authority' in this[y] || + (this[y][':authority'] = `${s}:${n}`)), + c && this.setTimeout(c), + r && this.once('response', r), + (this[D] = !1); + } + get method() { + return this[y][I]; + } + set method(e) { + e && (this[y][I] = e.toUpperCase()); + } + get path() { + return this[y][E]; + } + set path(e) { + e && (this[y][E] = e); + } + get _mustNotHaveABody() { + return ( + 'GET' === this.method || + 'HEAD' === this.method || + 'DELETE' === this.method + ); + } + _write(e, t, r) { + if (this._mustNotHaveABody) + return void r( + new Error( + 'The GET, HEAD and DELETE methods must NOT have a body' + ) + ); + this.flushHeaders(); + const A = () => this._request.write(e, t, r); + this._request ? A() : this[b].push(A); + } + _final(e) { + if (this.destroyed) return; + this.flushHeaders(); + const t = () => { + this._mustNotHaveABody ? e() : this._request.end(e); + }; + this._request ? t() : this[b].push(t); + } + abort() { + (this.res && this.res.complete) || + (this.aborted || process.nextTick(() => this.emit('abort')), + (this.aborted = !0), + this.destroy()); + } + _destroy(e, t) { + this.res && this.res._dump(), + this._request && this._request.destroy(), + t(e); + } + async flushHeaders() { + if (this[D] || this.destroyed) return; + this[D] = !0; + const e = this.method === B, + t = (t) => { + if (((this._request = t), this.destroyed)) + return void t.destroy(); + e || c(t, this, ['timeout', 'continue', 'close', 'error']); + const r = (e) => (...t) => { + this.writable || this.destroyed + ? this.once('finish', () => { + e(...t); + }) + : e(...t); + }; + t.once( + 'response', + r((r, A, n) => { + const o = new s(this.socket, t.readableHighWaterMark); + (this.res = o), + (o.req = this), + (o.statusCode = r[f]), + (o.headers = r), + (o.rawHeaders = n), + o.once('end', () => { + this.aborted + ? ((o.aborted = !0), o.emit('aborted')) + : ((o.complete = !0), + (o.socket = null), + (o.connection = null)); + }), + e + ? ((o.upgrade = !0), + this.emit('connect', o, t, Buffer.alloc(0)) + ? this.emit('close') + : t.destroy()) + : (t.on('data', (e) => { + o._dumped || o.push(e) || t.pause(); + }), + t.once('end', () => { + o.push(null); + }), + this.emit('response', o) || o._dump()); + }) + ), + t.once( + 'headers', + r((e) => this.emit('information', { statusCode: e[f] })) + ), + t.once( + 'trailers', + r((e, t, r) => { + const { res: A } = this; + (A.trailers = e), (A.rawTrailers = r); + }) + ); + const { socket: A } = t.session; + (this.socket = A), (this.connection = A); + for (const e of this[b]) e(); + this.emit('socket', this.socket); + }; + if (this[w]) + try { + t(this[w].request(this[y])); + } catch (e) { + this.emit('error', e); + } + else { + this.reusedSocket = !0; + try { + t(await this.agent.request(this[m], this[Q], this[y])); + } catch (e) { + this.emit('error', e); + } + } + } + getHeader(e) { + if ('string' != typeof e) throw new l('name', 'string', e); + return this[y][e.toLowerCase()]; + } + get headersSent() { + return this[D]; + } + removeHeader(e) { + if ('string' != typeof e) throw new l('name', 'string', e); + if (this.headersSent) throw new h('remove'); + delete this[y][e.toLowerCase()]; + } + setHeader(e, t) { + if (this.headersSent) throw new h('set'); + if ('string' != typeof e || (!v.test(e) && !g(e))) + throw new p('Header name', e); + if (void 0 === t) throw new d(t, e); + if (S.test(t)) throw new C('header content', e); + this[y][e.toLowerCase()] = t; + } + setNoDelay() {} + setSocketKeepAlive() {} + setTimeout(e, t) { + const r = () => this._request.setTimeout(e, t); + return this._request ? r() : this[b].push(r), this; + } + get maxHeadersCount() { + if (!this.destroyed && this._request) + return this._request.session.localSettings.maxHeaderListSize; + } + set maxHeadersCount(e) {} + }; + }, + 53433: (e, t, r) => { + 'use strict'; + const { Readable: A } = r(92413); + e.exports = class extends A { + constructor(e, t) { + super({ highWaterMark: t, autoDestroy: !1 }), + (this.statusCode = null), + (this.statusMessage = ''), + (this.httpVersion = '2.0'), + (this.httpVersionMajor = 2), + (this.httpVersionMinor = 0), + (this.headers = {}), + (this.trailers = {}), + (this.req = null), + (this.aborted = !1), + (this.complete = !1), + (this.upgrade = null), + (this.rawHeaders = []), + (this.rawTrailers = []), + (this.socket = e), + (this.connection = e), + (this._dumped = !1); + } + _destroy(e) { + this.req._request.destroy(e); + } + setTimeout(e, t) { + return this.req.setTimeout(e, t), this; + } + _dump() { + this._dumped || + ((this._dumped = !0), + this.removeAllListeners('data'), + this.resume()); + } + _read() { + this.req && this.req._request.resume(); + } + }; + }, + 92353: (e, t, r) => { + 'use strict'; + const A = r(97565), + n = r(94935), + o = r(33134), + i = r(53433), + s = r(2398); + e.exports = { + ...A, + ClientRequest: o, + IncomingMessage: i, + ...n, + request: (e, t, r) => new o(e, t, r), + get: (e, t, r) => { + const A = new o(e, t, r); + return A.end(), A; + }, + auto: s, + }; + }, + 5209: (e, t, r) => { + 'use strict'; + const A = r(11631); + e.exports = (e) => { + let t = e.host; + const r = e.headers && e.headers.host; + if (r) + if (r.startsWith('[')) { + t = -1 === r.indexOf(']') ? r : r.slice(1, -1); + } else t = r.split(':', 1)[0]; + return A.isIP(t) ? '' : t; + }; + }, + 64080: (e) => { + 'use strict'; + const t = (t, r, A) => { + e.exports[r] = class extends t { + constructor(...e) { + super('string' == typeof A ? A : A(e)), + (this.name = `${super.name} [${r}]`), + (this.code = r); + } + }; + }; + t(TypeError, 'ERR_INVALID_ARG_TYPE', (e) => { + const t = e[0].includes('.') ? 'property' : 'argument'; + let r = e[1]; + const A = Array.isArray(r); + return ( + A && (r = `${r.slice(0, -1).join(', ')} or ${r.slice(-1)}`), + `The "${e[0]}" ${t} must be ${ + A ? 'one of' : 'of' + } type ${r}. Received ${typeof e[2]}` + ); + }), + t( + TypeError, + 'ERR_INVALID_PROTOCOL', + (e) => `Protocol "${e[0]}" not supported. Expected "${e[1]}"` + ), + t( + Error, + 'ERR_HTTP_HEADERS_SENT', + (e) => `Cannot ${e[0]} headers after they are sent to the client` + ), + t( + TypeError, + 'ERR_INVALID_HTTP_TOKEN', + (e) => `${e[0]} must be a valid HTTP token [${e[1]}]` + ), + t( + TypeError, + 'ERR_HTTP_INVALID_HEADER_VALUE', + (e) => `Invalid value "${e[0]} for header "${e[1]}"` + ), + t( + TypeError, + 'ERR_INVALID_CHAR', + (e) => `Invalid character in ${e[0]} [${e[1]}]` + ); + }, + 50978: (e) => { + 'use strict'; + e.exports = (e) => { + switch (e) { + case ':method': + case ':scheme': + case ':authority': + case ':path': + return !0; + default: + return !1; + } + }; + }, + 66192: (e) => { + 'use strict'; + e.exports = (e, t, r) => { + for (const A of r) e.on(A, (...e) => t.emit(A, ...e)); + }; + }, + 50075: (e) => { + 'use strict'; + e.exports = (e) => { + const t = { + protocol: e.protocol, + hostname: + 'string' == typeof e.hostname && e.hostname.startsWith('[') + ? e.hostname.slice(1, -1) + : e.hostname, + host: e.host, + hash: e.hash, + search: e.search, + pathname: e.pathname, + href: e.href, + path: `${e.pathname || ''}${e.search || ''}`, + }; + return ( + 'string' == typeof e.port && + 0 !== e.port.length && + (t.port = Number(e.port)), + (e.username || e.password) && + (t.auth = `${e.username || ''}:${e.password || ''}`), + t + ); + }; + }, + 46458: (e) => { + function t(e) { + return Array.isArray(e) ? e : [e]; + } + const r = /^\s+$/, + A = /^\\!/, + n = /^\\#/, + o = /\r?\n/g, + i = /^\.*\/|^\.+$/, + s = + 'undefined' != typeof Symbol + ? Symbol.for('node-ignore') + : 'node-ignore', + a = /([0-z])-([0-z])/g, + c = [ + [/\\?\s+$/, (e) => (0 === e.indexOf('\\') ? ' ' : '')], + [/\\\s/g, () => ' '], + [/[\\^$.|*+(){]/g, (e) => '\\' + e], + [ + /\[([^\]/]*)($|\])/g, + (e, t, r) => { + return ']' === r + ? `[${ + ((A = t), + A.replace(a, (e, t, r) => + t.charCodeAt(0) <= r.charCodeAt(0) ? e : '' + )) + }]` + : '\\' + e; + var A; + }, + ], + [/(?!\\)\?/g, () => '[^/]'], + [/^\//, () => '^'], + [/\//g, () => '\\/'], + [/^\^*\\\*\\\*\\\//, () => '^(?:.*\\/)?'], + [/(?:[^*])$/, (e) => (/\/$/.test(e) ? e + '$' : e + '(?=$|\\/$)')], + [ + /^(?=[^^])/, + function () { + return /\/(?!$)/.test(this) ? '^' : '(?:^|\\/)'; + }, + ], + [ + /\\\/\\\*\\\*(?=\\\/|$)/g, + (e, t, r) => (t + 6 < r.length ? '(?:\\/[^\\/]+)*' : '\\/.+'), + ], + [/(^|[^\\]+)\\\*(?=.+)/g, (e, t) => t + '[^\\/]*'], + [ + /(\^|\\\/)?\\\*$/, + (e, t) => (t ? t + '[^/]+' : '[^/]*') + '(?=$|\\/$)', + ], + [/\\\\\\/g, () => '\\'], + ], + g = Object.create(null), + l = (e) => 'string' == typeof e; + class u { + constructor(e, t, r, A) { + (this.origin = e), + (this.pattern = t), + (this.negative = r), + (this.regex = A); + } + } + const h = (e, t) => { + const r = e; + let o = !1; + 0 === e.indexOf('!') && ((o = !0), (e = e.substr(1))); + const i = ((e, t, r) => { + const A = g[e]; + if (A) return A; + const n = c.reduce((t, r) => t.replace(r[0], r[1].bind(e)), e); + return (g[e] = r ? new RegExp(n, 'i') : new RegExp(n)); + })((e = e.replace(A, '!').replace(n, '#')), 0, t); + return new u(r, e, o, i); + }, + p = (e, t) => { + throw new t(e); + }, + d = (e, t, r) => { + if (!l(e)) + return r(`path must be a string, but got \`${t}\``, TypeError); + if (!e) return r('path must not be empty', TypeError); + if (d.isNotRelative(e)) { + return r( + `path should be a ${'`path.relative()`d'} string, but got "${t}"`, + RangeError + ); + } + return !0; + }, + C = (e) => i.test(e); + (d.isNotRelative = C), (d.convert = (e) => e); + class f { + constructor({ ignorecase: e = !0 } = {}) { + var t, r, A; + (this._rules = []), + (this._ignorecase = e), + (t = this), + (r = s), + (A = !0), + Object.defineProperty(t, r, { value: A }), + this._initCache(); + } + _initCache() { + (this._ignoreCache = Object.create(null)), + (this._testCache = Object.create(null)); + } + _addPattern(e) { + if (e && e[s]) + return ( + (this._rules = this._rules.concat(e._rules)), + void (this._added = !0) + ); + if (((e) => e && l(e) && !r.test(e) && 0 !== e.indexOf('#'))(e)) { + const t = h(e, this._ignorecase); + (this._added = !0), this._rules.push(t); + } + } + add(e) { + return ( + (this._added = !1), + t(l(e) ? ((e) => e.split(o))(e) : e).forEach( + this._addPattern, + this + ), + this._added && this._initCache(), + this + ); + } + addPattern(e) { + return this.add(e); + } + _testOne(e, t) { + let r = !1, + A = !1; + return ( + this._rules.forEach((n) => { + const { negative: o } = n; + if ((A === o && r !== A) || (o && !r && !A && !t)) return; + n.regex.test(e) && ((r = !o), (A = o)); + }), + { ignored: r, unignored: A } + ); + } + _test(e, t, r, A) { + const n = e && d.convert(e); + return d(n, e, p), this._t(n, t, r, A); + } + _t(e, t, r, A) { + if (e in t) return t[e]; + if ((A || (A = e.split('/')), A.pop(), !A.length)) + return (t[e] = this._testOne(e, r)); + const n = this._t(A.join('/') + '/', t, r, A); + return (t[e] = n.ignored ? n : this._testOne(e, r)); + } + ignores(e) { + return this._test(e, this._ignoreCache, !1).ignored; + } + createFilter() { + return (e) => !this.ignores(e); + } + filter(e) { + return t(e).filter(this.createFilter()); + } + test(e) { + return this._test(e, this._testCache, !0); + } + } + const I = (e) => new f(e), + E = () => !1; + if ( + ((I.isPathValid = (e) => d(e && d.convert(e), e, E)), + (I.default = I), + (e.exports = I), + 'undefined' != typeof process && + ((process.env && process.env.IGNORE_TEST_WIN32) || + 'win32' === process.platform)) + ) { + const e = (e) => + /^\\\\\?\\/.test(e) || /["<>|\u0000-\u001F]+/u.test(e) + ? e + : e.replace(/\\/g, '/'); + d.convert = e; + const t = /^[a-z]:\//i; + d.isNotRelative = (e) => t.test(e) || C(e); + } + }, + 85870: (e, t, r) => { + try { + var A = r(31669); + if ('function' != typeof A.inherits) throw ''; + e.exports = A.inherits; + } catch (t) { + e.exports = r(48145); + } + }, + 48145: (e) => { + 'function' == typeof Object.create + ? (e.exports = function (e, t) { + (e.super_ = t), + (e.prototype = Object.create(t.prototype, { + constructor: { + value: e, + enumerable: !1, + writable: !0, + configurable: !0, + }, + })); + }) + : (e.exports = function (e, t) { + e.super_ = t; + var r = function () {}; + (r.prototype = t.prototype), + (e.prototype = new r()), + (e.prototype.constructor = e); + }); + }, + 44486: (e) => { + /*! + * is-extglob + * + * Copyright (c) 2014-2016, Jon Schlinkert. + * Licensed under the MIT License. + */ + e.exports = function (e) { + if ('string' != typeof e || '' === e) return !1; + for (var t; (t = /(\\).|([@?!+*]\(.*\))/g.exec(e)); ) { + if (t[2]) return !0; + e = e.slice(t.index + t[0].length); + } + return !1; + }; + }, + 18193: (e, t, r) => { + /*! + * is-glob + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + var A = r(44486), + n = { '{': '}', '(': ')', '[': ']' }, + o = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/, + i = /\\(.)|(^!|[*?{}()[\]]|\(\?)/; + e.exports = function (e, t) { + if ('string' != typeof e || '' === e) return !1; + if (A(e)) return !0; + var r, + s = o; + for (t && !1 === t.strict && (s = i); (r = s.exec(e)); ) { + if (r[2]) return !0; + var a = r.index + r[0].length, + c = r[1], + g = c ? n[c] : null; + if (c && g) { + var l = e.indexOf(g, a); + -1 !== l && (a = l + 1); + } + e = e.slice(a); + } + return !1; + }; + }, + 59235: (e) => { + 'use strict'; + /*! + * is-number + * + * Copyright (c) 2014-present, Jon Schlinkert. + * Released under the MIT License. + */ e.exports = function (e) { + return 'number' == typeof e + ? e - e == 0 + : 'string' == typeof e && + '' !== e.trim() && + (Number.isFinite ? Number.isFinite(+e) : isFinite(+e)); + }; + }, + 97369: (e, t) => { + var r, A, n, o; + /*! + * is-windows + * + * Copyright © 2015-2018, Jon Schlinkert. + * Released under the MIT License. + */ (o = function () { + 'use strict'; + return function () { + return ( + process && + ('win32' === process.platform || + /^(msys|cygwin)$/.test(process.env.OSTYPE)) + ); + }; + }), + t && 'object' == typeof t + ? (e.exports = o()) + : ((A = []), + void 0 === + (n = 'function' == typeof (r = o) ? r.apply(t, A) : r) || + (e.exports = n)); + }, + 64151: (e, t, r) => { + var A; + r(35747); + function n(e, t, r) { + if (('function' == typeof t && ((r = t), (t = {})), !r)) { + if ('function' != typeof Promise) + throw new TypeError('callback not provided'); + return new Promise(function (r, A) { + n(e, t || {}, function (e, t) { + e ? A(e) : r(t); + }); + }); + } + A(e, t || {}, function (e, A) { + e && + ('EACCES' === e.code || (t && t.ignoreErrors)) && + ((e = null), (A = !1)), + r(e, A); + }); + } + (A = + 'win32' === process.platform || global.TESTING_WINDOWS + ? r(3202) + : r(2151)), + (e.exports = n), + (n.sync = function (e, t) { + try { + return A.sync(e, t || {}); + } catch (e) { + if ((t && t.ignoreErrors) || 'EACCES' === e.code) return !1; + throw e; + } + }); + }, + 2151: (e, t, r) => { + (e.exports = n), + (n.sync = function (e, t) { + return o(A.statSync(e), t); + }); + var A = r(35747); + function n(e, t, r) { + A.stat(e, function (e, A) { + r(e, !e && o(A, t)); + }); + } + function o(e, t) { + return ( + e.isFile() && + (function (e, t) { + var r = e.mode, + A = e.uid, + n = e.gid, + o = + void 0 !== t.uid ? t.uid : process.getuid && process.getuid(), + i = + void 0 !== t.gid ? t.gid : process.getgid && process.getgid(), + s = parseInt('100', 8), + a = parseInt('010', 8), + c = parseInt('001', 8), + g = s | a; + return ( + r & c || + (r & a && n === i) || + (r & s && A === o) || + (r & g && 0 === o) + ); + })(e, t) + ); + } + }, + 3202: (e, t, r) => { + (e.exports = o), + (o.sync = function (e, t) { + return n(A.statSync(e), e, t); + }); + var A = r(35747); + function n(e, t, r) { + return ( + !(!e.isSymbolicLink() && !e.isFile()) && + (function (e, t) { + var r = void 0 !== t.pathExt ? t.pathExt : process.env.PATHEXT; + if (!r) return !0; + if (-1 !== (r = r.split(';')).indexOf('')) return !0; + for (var A = 0; A < r.length; A++) { + var n = r[A].toLowerCase(); + if (n && e.substr(-n.length).toLowerCase() === n) return !0; + } + return !1; + })(t, r) + ); + } + function o(e, t, r) { + A.stat(e, function (A, o) { + r(A, !A && n(o, e, t)); + }); + } + }, + 21194: (e, t, r) => { + 'use strict'; + var A = r(40744); + e.exports = A; + }, + 40744: (e, t, r) => { + 'use strict'; + var A = r(55384), + n = r(24129); + function o(e) { + return function () { + throw new Error( + 'Function ' + e + ' is deprecated and cannot be used.' + ); + }; + } + (e.exports.Type = r(81704)), + (e.exports.Schema = r(8212)), + (e.exports.FAILSAFE_SCHEMA = r(44413)), + (e.exports.JSON_SCHEMA = r(45247)), + (e.exports.CORE_SCHEMA = r(8769)), + (e.exports.DEFAULT_SAFE_SCHEMA = r(65483)), + (e.exports.DEFAULT_FULL_SCHEMA = r(5235)), + (e.exports.load = A.load), + (e.exports.loadAll = A.loadAll), + (e.exports.safeLoad = A.safeLoad), + (e.exports.safeLoadAll = A.safeLoadAll), + (e.exports.dump = n.dump), + (e.exports.safeDump = n.safeDump), + (e.exports.YAMLException = r(17345)), + (e.exports.MINIMAL_SCHEMA = r(44413)), + (e.exports.SAFE_SCHEMA = r(65483)), + (e.exports.DEFAULT_SCHEMA = r(5235)), + (e.exports.scan = o('scan')), + (e.exports.parse = o('parse')), + (e.exports.compose = o('compose')), + (e.exports.addConstructor = o('addConstructor')); + }, + 28149: (e) => { + 'use strict'; + function t(e) { + return null == e; + } + (e.exports.isNothing = t), + (e.exports.isObject = function (e) { + return 'object' == typeof e && null !== e; + }), + (e.exports.toArray = function (e) { + return Array.isArray(e) ? e : t(e) ? [] : [e]; + }), + (e.exports.repeat = function (e, t) { + var r, + A = ''; + for (r = 0; r < t; r += 1) A += e; + return A; + }), + (e.exports.isNegativeZero = function (e) { + return 0 === e && Number.NEGATIVE_INFINITY === 1 / e; + }), + (e.exports.extend = function (e, t) { + var r, A, n, o; + if (t) + for (r = 0, A = (o = Object.keys(t)).length; r < A; r += 1) + e[(n = o[r])] = t[n]; + return e; + }); + }, + 24129: (e, t, r) => { + 'use strict'; + var A = r(28149), + n = r(17345), + o = r(5235), + i = r(65483), + s = Object.prototype.toString, + a = Object.prototype.hasOwnProperty, + c = { + 0: '\\0', + 7: '\\a', + 8: '\\b', + 9: '\\t', + 10: '\\n', + 11: '\\v', + 12: '\\f', + 13: '\\r', + 27: '\\e', + 34: '\\"', + 92: '\\\\', + 133: '\\N', + 160: '\\_', + 8232: '\\L', + 8233: '\\P', + }, + g = [ + 'y', + 'Y', + 'yes', + 'Yes', + 'YES', + 'on', + 'On', + 'ON', + 'n', + 'N', + 'no', + 'No', + 'NO', + 'off', + 'Off', + 'OFF', + ]; + function l(e) { + var t, r, o; + if (((t = e.toString(16).toUpperCase()), e <= 255)) + (r = 'x'), (o = 2); + else if (e <= 65535) (r = 'u'), (o = 4); + else { + if (!(e <= 4294967295)) + throw new n( + 'code point within a string may not be greater than 0xFFFFFFFF' + ); + (r = 'U'), (o = 8); + } + return '\\' + r + A.repeat('0', o - t.length) + t; + } + function u(e) { + (this.schema = e.schema || o), + (this.indent = Math.max(1, e.indent || 2)), + (this.noArrayIndent = e.noArrayIndent || !1), + (this.skipInvalid = e.skipInvalid || !1), + (this.flowLevel = A.isNothing(e.flowLevel) ? -1 : e.flowLevel), + (this.styleMap = (function (e, t) { + var r, A, n, o, i, s, c; + if (null === t) return {}; + for ( + r = {}, n = 0, o = (A = Object.keys(t)).length; + n < o; + n += 1 + ) + (i = A[n]), + (s = String(t[i])), + '!!' === i.slice(0, 2) && + (i = 'tag:yaml.org,2002:' + i.slice(2)), + (c = e.compiledTypeMap.fallback[i]) && + a.call(c.styleAliases, s) && + (s = c.styleAliases[s]), + (r[i] = s); + return r; + })(this.schema, e.styles || null)), + (this.sortKeys = e.sortKeys || !1), + (this.lineWidth = e.lineWidth || 80), + (this.noRefs = e.noRefs || !1), + (this.noCompatMode = e.noCompatMode || !1), + (this.condenseFlow = e.condenseFlow || !1), + (this.implicitTypes = this.schema.compiledImplicit), + (this.explicitTypes = this.schema.compiledExplicit), + (this.tag = null), + (this.result = ''), + (this.duplicates = []), + (this.usedDuplicates = null); + } + function h(e, t) { + for ( + var r, n = A.repeat(' ', t), o = 0, i = -1, s = '', a = e.length; + o < a; + + ) + -1 === (i = e.indexOf('\n', o)) + ? ((r = e.slice(o)), (o = a)) + : ((r = e.slice(o, i + 1)), (o = i + 1)), + r.length && '\n' !== r && (s += n), + (s += r); + return s; + } + function p(e, t) { + return '\n' + A.repeat(' ', e.indent * t); + } + function d(e) { + return 32 === e || 9 === e; + } + function C(e) { + return ( + (32 <= e && e <= 126) || + (161 <= e && e <= 55295 && 8232 !== e && 8233 !== e) || + (57344 <= e && e <= 65533 && 65279 !== e) || + (65536 <= e && e <= 1114111) + ); + } + function f(e) { + return ( + C(e) && + 65279 !== e && + 44 !== e && + 91 !== e && + 93 !== e && + 123 !== e && + 125 !== e && + 58 !== e && + 35 !== e + ); + } + function I(e) { + return /^\n* /.test(e); + } + function E(e, t, r, A, n) { + var o, + i, + s, + a = !1, + c = !1, + g = -1 !== A, + l = -1, + u = + C((s = e.charCodeAt(0))) && + 65279 !== s && + !d(s) && + 45 !== s && + 63 !== s && + 58 !== s && + 44 !== s && + 91 !== s && + 93 !== s && + 123 !== s && + 125 !== s && + 35 !== s && + 38 !== s && + 42 !== s && + 33 !== s && + 124 !== s && + 62 !== s && + 39 !== s && + 34 !== s && + 37 !== s && + 64 !== s && + 96 !== s && + !d(e.charCodeAt(e.length - 1)); + if (t) + for (o = 0; o < e.length; o++) { + if (!C((i = e.charCodeAt(o)))) return 5; + u = u && f(i); + } + else { + for (o = 0; o < e.length; o++) { + if (10 === (i = e.charCodeAt(o))) + (a = !0), + g && + ((c = c || (o - l - 1 > A && ' ' !== e[l + 1])), (l = o)); + else if (!C(i)) return 5; + u = u && f(i); + } + c = c || (g && o - l - 1 > A && ' ' !== e[l + 1]); + } + return a || c ? (r > 9 && I(e) ? 5 : c ? 4 : 3) : u && !n(e) ? 1 : 2; + } + function B(e, t, r, A) { + e.dump = (function () { + if (0 === t.length) return "''"; + if (!e.noCompatMode && -1 !== g.indexOf(t)) return "'" + t + "'"; + var o = e.indent * Math.max(1, r), + i = + -1 === e.lineWidth + ? -1 + : Math.max(Math.min(e.lineWidth, 40), e.lineWidth - o), + s = A || (e.flowLevel > -1 && r >= e.flowLevel); + switch ( + E(t, s, e.indent, i, function (t) { + return (function (e, t) { + var r, A; + for (r = 0, A = e.implicitTypes.length; r < A; r += 1) + if (e.implicitTypes[r].resolve(t)) return !0; + return !1; + })(e, t); + }) + ) { + case 1: + return t; + case 2: + return "'" + t.replace(/'/g, "''") + "'"; + case 3: + return '|' + y(t, e.indent) + m(h(t, o)); + case 4: + return ( + '>' + + y(t, e.indent) + + m( + h( + (function (e, t) { + var r, + A, + n = /(\n+)([^\n]*)/g, + o = + ((s = e.indexOf('\n')), + (s = -1 !== s ? s : e.length), + (n.lastIndex = s), + w(e.slice(0, s), t)), + i = '\n' === e[0] || ' ' === e[0]; + var s; + for (; (A = n.exec(e)); ) { + var a = A[1], + c = A[2]; + (r = ' ' === c[0]), + (o += + a + (i || r || '' === c ? '' : '\n') + w(c, t)), + (i = r); + } + return o; + })(t, i), + o + ) + ) + ); + case 5: + return ( + '"' + + (function (e) { + for (var t, r, A, n = '', o = 0; o < e.length; o++) + (t = e.charCodeAt(o)) >= 55296 && + t <= 56319 && + (r = e.charCodeAt(o + 1)) >= 56320 && + r <= 57343 + ? ((n += l(1024 * (t - 55296) + r - 56320 + 65536)), + o++) + : ((A = c[t]), (n += !A && C(t) ? e[o] : A || l(t))); + return n; + })(t) + + '"' + ); + default: + throw new n('impossible error: invalid scalar style'); + } + })(); + } + function y(e, t) { + var r = I(e) ? String(t) : '', + A = '\n' === e[e.length - 1]; + return ( + r + + (A && ('\n' === e[e.length - 2] || '\n' === e) + ? '+' + : A + ? '' + : '-') + + '\n' + ); + } + function m(e) { + return '\n' === e[e.length - 1] ? e.slice(0, -1) : e; + } + function w(e, t) { + if ('' === e || ' ' === e[0]) return e; + for ( + var r, A, n = / [^ ]/g, o = 0, i = 0, s = 0, a = ''; + (r = n.exec(e)); + + ) + (s = r.index) - o > t && + ((A = i > o ? i : s), (a += '\n' + e.slice(o, A)), (o = A + 1)), + (i = s); + return ( + (a += '\n'), + e.length - o > t && i > o + ? (a += e.slice(o, i) + '\n' + e.slice(i + 1)) + : (a += e.slice(o)), + a.slice(1) + ); + } + function Q(e, t, r) { + var A, o, i, c, g, l; + for ( + i = 0, c = (o = r ? e.explicitTypes : e.implicitTypes).length; + i < c; + i += 1 + ) + if ( + ((g = o[i]).instanceOf || g.predicate) && + (!g.instanceOf || + ('object' == typeof t && t instanceof g.instanceOf)) && + (!g.predicate || g.predicate(t)) + ) { + if (((e.tag = r ? g.tag : '?'), g.represent)) { + if ( + ((l = e.styleMap[g.tag] || g.defaultStyle), + '[object Function]' === s.call(g.represent)) + ) + A = g.represent(t, l); + else { + if (!a.call(g.represent, l)) + throw new n( + '!<' + + g.tag + + '> tag resolver accepts not "' + + l + + '" style' + ); + A = g.represent[l](t, l); + } + e.dump = A; + } + return !0; + } + return !1; + } + function D(e, t, r, A, o, i) { + (e.tag = null), (e.dump = r), Q(e, r, !1) || Q(e, r, !0); + var a = s.call(e.dump); + A && (A = e.flowLevel < 0 || e.flowLevel > t); + var c, + g, + l = '[object Object]' === a || '[object Array]' === a; + if ( + (l && (g = -1 !== (c = e.duplicates.indexOf(r))), + ((null !== e.tag && '?' !== e.tag) || + g || + (2 !== e.indent && t > 0)) && + (o = !1), + g && e.usedDuplicates[c]) + ) + e.dump = '*ref_' + c; + else { + if ( + (l && g && !e.usedDuplicates[c] && (e.usedDuplicates[c] = !0), + '[object Object]' === a) + ) + A && 0 !== Object.keys(e.dump).length + ? (!(function (e, t, r, A) { + var o, + i, + s, + a, + c, + g, + l = '', + u = e.tag, + h = Object.keys(r); + if (!0 === e.sortKeys) h.sort(); + else if ('function' == typeof e.sortKeys) + h.sort(e.sortKeys); + else if (e.sortKeys) + throw new n('sortKeys must be a boolean or a function'); + for (o = 0, i = h.length; o < i; o += 1) + (g = ''), + (A && 0 === o) || (g += p(e, t)), + (a = r[(s = h[o])]), + D(e, t + 1, s, !0, !0, !0) && + ((c = + (null !== e.tag && '?' !== e.tag) || + (e.dump && e.dump.length > 1024)) && + (e.dump && 10 === e.dump.charCodeAt(0) + ? (g += '?') + : (g += '? ')), + (g += e.dump), + c && (g += p(e, t)), + D(e, t + 1, a, !0, c) && + (e.dump && 10 === e.dump.charCodeAt(0) + ? (g += ':') + : (g += ': '), + (l += g += e.dump))); + (e.tag = u), (e.dump = l || '{}'); + })(e, t, e.dump, o), + g && (e.dump = '&ref_' + c + e.dump)) + : (!(function (e, t, r) { + var A, + n, + o, + i, + s, + a = '', + c = e.tag, + g = Object.keys(r); + for (A = 0, n = g.length; A < n; A += 1) + (s = e.condenseFlow ? '"' : ''), + 0 !== A && (s += ', '), + (i = r[(o = g[A])]), + D(e, t, o, !1, !1) && + (e.dump.length > 1024 && (s += '? '), + (s += + e.dump + + (e.condenseFlow ? '"' : '') + + ':' + + (e.condenseFlow ? '' : ' ')), + D(e, t, i, !1, !1) && (a += s += e.dump)); + (e.tag = c), (e.dump = '{' + a + '}'); + })(e, t, e.dump), + g && (e.dump = '&ref_' + c + ' ' + e.dump)); + else if ('[object Array]' === a) { + var u = e.noArrayIndent && t > 0 ? t - 1 : t; + A && 0 !== e.dump.length + ? (!(function (e, t, r, A) { + var n, + o, + i = '', + s = e.tag; + for (n = 0, o = r.length; n < o; n += 1) + D(e, t + 1, r[n], !0, !0) && + ((A && 0 === n) || (i += p(e, t)), + e.dump && 10 === e.dump.charCodeAt(0) + ? (i += '-') + : (i += '- '), + (i += e.dump)); + (e.tag = s), (e.dump = i || '[]'); + })(e, u, e.dump, o), + g && (e.dump = '&ref_' + c + e.dump)) + : (!(function (e, t, r) { + var A, + n, + o = '', + i = e.tag; + for (A = 0, n = r.length; A < n; A += 1) + D(e, t, r[A], !1, !1) && + (0 !== A && (o += ',' + (e.condenseFlow ? '' : ' ')), + (o += e.dump)); + (e.tag = i), (e.dump = '[' + o + ']'); + })(e, u, e.dump), + g && (e.dump = '&ref_' + c + ' ' + e.dump)); + } else { + if ('[object String]' !== a) { + if (e.skipInvalid) return !1; + throw new n('unacceptable kind of an object to dump ' + a); + } + '?' !== e.tag && B(e, e.dump, t, i); + } + null !== e.tag && + '?' !== e.tag && + (e.dump = '!<' + e.tag + '> ' + e.dump); + } + return !0; + } + function b(e, t) { + var r, + A, + n = [], + o = []; + for ( + (function e(t, r, A) { + var n, o, i; + if (null !== t && 'object' == typeof t) + if (-1 !== (o = r.indexOf(t))) -1 === A.indexOf(o) && A.push(o); + else if ((r.push(t), Array.isArray(t))) + for (o = 0, i = t.length; o < i; o += 1) e(t[o], r, A); + else + for (n = Object.keys(t), o = 0, i = n.length; o < i; o += 1) + e(t[n[o]], r, A); + })(e, n, o), + r = 0, + A = o.length; + r < A; + r += 1 + ) + t.duplicates.push(n[o[r]]); + t.usedDuplicates = new Array(A); + } + function v(e, t) { + var r = new u((t = t || {})); + return r.noRefs || b(e, r), D(r, 0, e, !0, !0) ? r.dump + '\n' : ''; + } + (e.exports.dump = v), + (e.exports.safeDump = function (e, t) { + return v(e, A.extend({ schema: i }, t)); + }); + }, + 17345: (e) => { + 'use strict'; + function t(e, t) { + Error.call(this), + (this.name = 'YAMLException'), + (this.reason = e), + (this.mark = t), + (this.message = + (this.reason || '(unknown reason)') + + (this.mark ? ' ' + this.mark.toString() : '')), + Error.captureStackTrace + ? Error.captureStackTrace(this, this.constructor) + : (this.stack = new Error().stack || ''); + } + (t.prototype = Object.create(Error.prototype)), + (t.prototype.constructor = t), + (t.prototype.toString = function (e) { + var t = this.name + ': '; + return ( + (t += this.reason || '(unknown reason)'), + !e && this.mark && (t += ' ' + this.mark.toString()), + t + ); + }), + (e.exports = t); + }, + 55384: (e, t, r) => { + 'use strict'; + var A = r(28149), + n = r(17345), + o = r(30399), + i = r(65483), + s = r(5235), + a = Object.prototype.hasOwnProperty, + c = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/, + g = /[\x85\u2028\u2029]/, + l = /[,\[\]\{\}]/, + u = /^(?:!|!!|![a-z\-]+!)$/i, + h = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + function p(e) { + return 10 === e || 13 === e; + } + function d(e) { + return 9 === e || 32 === e; + } + function C(e) { + return 9 === e || 32 === e || 10 === e || 13 === e; + } + function f(e) { + return 44 === e || 91 === e || 93 === e || 123 === e || 125 === e; + } + function I(e) { + var t; + return 48 <= e && e <= 57 + ? e - 48 + : 97 <= (t = 32 | e) && t <= 102 + ? t - 97 + 10 + : -1; + } + function E(e) { + return 48 === e + ? '\0' + : 97 === e + ? '' + : 98 === e + ? '\b' + : 116 === e || 9 === e + ? '\t' + : 110 === e + ? '\n' + : 118 === e + ? '\v' + : 102 === e + ? '\f' + : 114 === e + ? '\r' + : 101 === e + ? '' + : 32 === e + ? ' ' + : 34 === e + ? '"' + : 47 === e + ? '/' + : 92 === e + ? '\\' + : 78 === e + ? '…' + : 95 === e + ? ' ' + : 76 === e + ? '\u2028' + : 80 === e + ? '\u2029' + : ''; + } + function B(e) { + return e <= 65535 + ? String.fromCharCode(e) + : String.fromCharCode( + 55296 + ((e - 65536) >> 10), + 56320 + ((e - 65536) & 1023) + ); + } + for (var y = new Array(256), m = new Array(256), w = 0; w < 256; w++) + (y[w] = E(w) ? 1 : 0), (m[w] = E(w)); + function Q(e, t) { + (this.input = e), + (this.filename = t.filename || null), + (this.schema = t.schema || s), + (this.onWarning = t.onWarning || null), + (this.legacy = t.legacy || !1), + (this.json = t.json || !1), + (this.listener = t.listener || null), + (this.implicitTypes = this.schema.compiledImplicit), + (this.typeMap = this.schema.compiledTypeMap), + (this.length = e.length), + (this.position = 0), + (this.line = 0), + (this.lineStart = 0), + (this.lineIndent = 0), + (this.documents = []); + } + function D(e, t) { + return new n( + t, + new o( + e.filename, + e.input, + e.position, + e.line, + e.position - e.lineStart + ) + ); + } + function b(e, t) { + throw D(e, t); + } + function v(e, t) { + e.onWarning && e.onWarning.call(null, D(e, t)); + } + var S = { + YAML: function (e, t, r) { + var A, n, o; + null !== e.version && b(e, 'duplication of %YAML directive'), + 1 !== r.length && + b(e, 'YAML directive accepts exactly one argument'), + null === (A = /^([0-9]+)\.([0-9]+)$/.exec(r[0])) && + b(e, 'ill-formed argument of the YAML directive'), + (n = parseInt(A[1], 10)), + (o = parseInt(A[2], 10)), + 1 !== n && b(e, 'unacceptable YAML version of the document'), + (e.version = r[0]), + (e.checkLineBreaks = o < 2), + 1 !== o && + 2 !== o && + v(e, 'unsupported YAML version of the document'); + }, + TAG: function (e, t, r) { + var A, n; + 2 !== r.length && + b(e, 'TAG directive accepts exactly two arguments'), + (A = r[0]), + (n = r[1]), + u.test(A) || + b( + e, + 'ill-formed tag handle (first argument) of the TAG directive' + ), + a.call(e.tagMap, A) && + b( + e, + 'there is a previously declared suffix for "' + + A + + '" tag handle' + ), + h.test(n) || + b( + e, + 'ill-formed tag prefix (second argument) of the TAG directive' + ), + (e.tagMap[A] = n); + }, + }; + function k(e, t, r, A) { + var n, o, i, s; + if (t < r) { + if (((s = e.input.slice(t, r)), A)) + for (n = 0, o = s.length; n < o; n += 1) + 9 === (i = s.charCodeAt(n)) || + (32 <= i && i <= 1114111) || + b(e, 'expected valid JSON character'); + else + c.test(s) && b(e, 'the stream contains non-printable characters'); + e.result += s; + } + } + function N(e, t, r, n) { + var o, i, s, c; + for ( + A.isObject(r) || + b( + e, + 'cannot merge mappings; the provided source object is unacceptable' + ), + s = 0, + c = (o = Object.keys(r)).length; + s < c; + s += 1 + ) + (i = o[s]), a.call(t, i) || ((t[i] = r[i]), (n[i] = !0)); + } + function F(e, t, r, A, n, o, i, s) { + var c, g; + if ( + ((n = String(n)), + null === t && (t = {}), + 'tag:yaml.org,2002:merge' === A) + ) + if (Array.isArray(o)) + for (c = 0, g = o.length; c < g; c += 1) N(e, t, o[c], r); + else N(e, t, o, r); + else + e.json || + a.call(r, n) || + !a.call(t, n) || + ((e.line = i || e.line), + (e.position = s || e.position), + b(e, 'duplicated mapping key')), + (t[n] = o), + delete r[n]; + return t; + } + function K(e) { + var t; + 10 === (t = e.input.charCodeAt(e.position)) + ? e.position++ + : 13 === t + ? (e.position++, + 10 === e.input.charCodeAt(e.position) && e.position++) + : b(e, 'a line break is expected'), + (e.line += 1), + (e.lineStart = e.position); + } + function M(e, t, r) { + for (var A = 0, n = e.input.charCodeAt(e.position); 0 !== n; ) { + for (; d(n); ) n = e.input.charCodeAt(++e.position); + if (t && 35 === n) + do { + n = e.input.charCodeAt(++e.position); + } while (10 !== n && 13 !== n && 0 !== n); + if (!p(n)) break; + for ( + K(e), n = e.input.charCodeAt(e.position), A++, e.lineIndent = 0; + 32 === n; + + ) + e.lineIndent++, (n = e.input.charCodeAt(++e.position)); + } + return ( + -1 !== r && + 0 !== A && + e.lineIndent < r && + v(e, 'deficient indentation'), + A + ); + } + function R(e) { + var t, + r = e.position; + return !( + (45 !== (t = e.input.charCodeAt(r)) && 46 !== t) || + t !== e.input.charCodeAt(r + 1) || + t !== e.input.charCodeAt(r + 2) || + ((r += 3), 0 !== (t = e.input.charCodeAt(r)) && !C(t)) + ); + } + function x(e, t) { + 1 === t + ? (e.result += ' ') + : t > 1 && (e.result += A.repeat('\n', t - 1)); + } + function L(e, t) { + var r, + A, + n = e.tag, + o = e.anchor, + i = [], + s = !1; + for ( + null !== e.anchor && (e.anchorMap[e.anchor] = i), + A = e.input.charCodeAt(e.position); + 0 !== A && 45 === A && C(e.input.charCodeAt(e.position + 1)); + + ) + if (((s = !0), e.position++, M(e, !0, -1) && e.lineIndent <= t)) + i.push(null), (A = e.input.charCodeAt(e.position)); + else if ( + ((r = e.line), + U(e, t, 3, !1, !0), + i.push(e.result), + M(e, !0, -1), + (A = e.input.charCodeAt(e.position)), + (e.line === r || e.lineIndent > t) && 0 !== A) + ) + b(e, 'bad indentation of a sequence entry'); + else if (e.lineIndent < t) break; + return ( + !!s && + ((e.tag = n), + (e.anchor = o), + (e.kind = 'sequence'), + (e.result = i), + !0) + ); + } + function P(e) { + var t, + r, + A, + n, + o = !1, + i = !1; + if (33 !== (n = e.input.charCodeAt(e.position))) return !1; + if ( + (null !== e.tag && b(e, 'duplication of a tag property'), + 60 === (n = e.input.charCodeAt(++e.position)) + ? ((o = !0), (n = e.input.charCodeAt(++e.position))) + : 33 === n + ? ((i = !0), (r = '!!'), (n = e.input.charCodeAt(++e.position))) + : (r = '!'), + (t = e.position), + o) + ) { + do { + n = e.input.charCodeAt(++e.position); + } while (0 !== n && 62 !== n); + e.position < e.length + ? ((A = e.input.slice(t, e.position)), + (n = e.input.charCodeAt(++e.position))) + : b(e, 'unexpected end of the stream within a verbatim tag'); + } else { + for (; 0 !== n && !C(n); ) + 33 === n && + (i + ? b(e, 'tag suffix cannot contain exclamation marks') + : ((r = e.input.slice(t - 1, e.position + 1)), + u.test(r) || + b(e, 'named tag handle cannot contain such characters'), + (i = !0), + (t = e.position + 1))), + (n = e.input.charCodeAt(++e.position)); + (A = e.input.slice(t, e.position)), + l.test(A) && + b(e, 'tag suffix cannot contain flow indicator characters'); + } + return ( + A && + !h.test(A) && + b(e, 'tag name cannot contain such characters: ' + A), + o + ? (e.tag = A) + : a.call(e.tagMap, r) + ? (e.tag = e.tagMap[r] + A) + : '!' === r + ? (e.tag = '!' + A) + : '!!' === r + ? (e.tag = 'tag:yaml.org,2002:' + A) + : b(e, 'undeclared tag handle "' + r + '"'), + !0 + ); + } + function O(e) { + var t, r; + if (38 !== (r = e.input.charCodeAt(e.position))) return !1; + for ( + null !== e.anchor && b(e, 'duplication of an anchor property'), + r = e.input.charCodeAt(++e.position), + t = e.position; + 0 !== r && !C(r) && !f(r); + + ) + r = e.input.charCodeAt(++e.position); + return ( + e.position === t && + b( + e, + 'name of an anchor node must contain at least one character' + ), + (e.anchor = e.input.slice(t, e.position)), + !0 + ); + } + function U(e, t, r, n, o) { + var i, + s, + c, + g, + l, + u, + h, + E, + w = 1, + Q = !1, + D = !1; + if ( + (null !== e.listener && e.listener('open', e), + (e.tag = null), + (e.anchor = null), + (e.kind = null), + (e.result = null), + (i = s = c = 4 === r || 3 === r), + n && + M(e, !0, -1) && + ((Q = !0), + e.lineIndent > t + ? (w = 1) + : e.lineIndent === t + ? (w = 0) + : e.lineIndent < t && (w = -1)), + 1 === w) + ) + for (; P(e) || O(e); ) + M(e, !0, -1) + ? ((Q = !0), + (c = i), + e.lineIndent > t + ? (w = 1) + : e.lineIndent === t + ? (w = 0) + : e.lineIndent < t && (w = -1)) + : (c = !1); + if ( + (c && (c = Q || o), + (1 !== w && 4 !== r) || + ((h = 1 === r || 2 === r ? t : t + 1), + (E = e.position - e.lineStart), + 1 === w + ? (c && + (L(e, E) || + (function (e, t, r) { + var A, + n, + o, + i, + s, + a = e.tag, + c = e.anchor, + g = {}, + l = {}, + u = null, + h = null, + p = null, + f = !1, + I = !1; + for ( + null !== e.anchor && (e.anchorMap[e.anchor] = g), + s = e.input.charCodeAt(e.position); + 0 !== s; + + ) { + if ( + ((A = e.input.charCodeAt(e.position + 1)), + (o = e.line), + (i = e.position), + (63 !== s && 58 !== s) || !C(A)) + ) { + if (!U(e, r, 2, !1, !0)) break; + if (e.line === o) { + for (s = e.input.charCodeAt(e.position); d(s); ) + s = e.input.charCodeAt(++e.position); + if (58 === s) + C((s = e.input.charCodeAt(++e.position))) || + b( + e, + 'a whitespace character is expected after the key-value separator within a block mapping' + ), + f && + (F(e, g, l, u, h, null), + (u = h = p = null)), + (I = !0), + (f = !1), + (n = !1), + (u = e.tag), + (h = e.result); + else { + if (!I) return (e.tag = a), (e.anchor = c), !0; + b( + e, + 'can not read an implicit mapping pair; a colon is missed' + ); + } + } else { + if (!I) return (e.tag = a), (e.anchor = c), !0; + b( + e, + 'can not read a block mapping entry; a multiline key may not be an implicit key' + ); + } + } else + 63 === s + ? (f && + (F(e, g, l, u, h, null), (u = h = p = null)), + (I = !0), + (f = !0), + (n = !0)) + : f + ? ((f = !1), (n = !0)) + : b( + e, + 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line' + ), + (e.position += 1), + (s = A); + if ( + ((e.line === o || e.lineIndent > t) && + (U(e, t, 4, !0, n) && + (f ? (h = e.result) : (p = e.result)), + f || + (F(e, g, l, u, h, p, o, i), (u = h = p = null)), + M(e, !0, -1), + (s = e.input.charCodeAt(e.position))), + e.lineIndent > t && 0 !== s) + ) + b(e, 'bad indentation of a mapping entry'); + else if (e.lineIndent < t) break; + } + return ( + f && F(e, g, l, u, h, null), + I && + ((e.tag = a), + (e.anchor = c), + (e.kind = 'mapping'), + (e.result = g)), + I + ); + })(e, E, h))) || + (function (e, t) { + var r, + A, + n, + o, + i, + s, + a, + c, + g, + l, + u = !0, + h = e.tag, + p = e.anchor, + d = {}; + if (91 === (l = e.input.charCodeAt(e.position))) + (n = 93), (s = !1), (A = []); + else { + if (123 !== l) return !1; + (n = 125), (s = !0), (A = {}); + } + for ( + null !== e.anchor && (e.anchorMap[e.anchor] = A), + l = e.input.charCodeAt(++e.position); + 0 !== l; + + ) { + if ( + (M(e, !0, t), + (l = e.input.charCodeAt(e.position)) === n) + ) + return ( + e.position++, + (e.tag = h), + (e.anchor = p), + (e.kind = s ? 'mapping' : 'sequence'), + (e.result = A), + !0 + ); + u || b(e, 'missed comma between flow collection entries'), + (g = null), + (o = i = !1), + 63 === l && + C(e.input.charCodeAt(e.position + 1)) && + ((o = i = !0), e.position++, M(e, !0, t)), + (r = e.line), + U(e, t, 1, !1, !0), + (c = e.tag), + (a = e.result), + M(e, !0, t), + (l = e.input.charCodeAt(e.position)), + (!i && e.line !== r) || + 58 !== l || + ((o = !0), + (l = e.input.charCodeAt(++e.position)), + M(e, !0, t), + U(e, t, 1, !1, !0), + (g = e.result)), + s + ? F(e, A, d, c, a, g) + : o + ? A.push(F(e, null, d, c, a, g)) + : A.push(a), + M(e, !0, t), + 44 === (l = e.input.charCodeAt(e.position)) + ? ((u = !0), (l = e.input.charCodeAt(++e.position))) + : (u = !1); + } + b( + e, + 'unexpected end of the stream within a flow collection' + ); + })(e, h) + ? (D = !0) + : ((s && + (function (e, t) { + var r, + n, + o, + i, + s, + a = 1, + c = !1, + g = !1, + l = t, + u = 0, + h = !1; + if (124 === (i = e.input.charCodeAt(e.position))) + n = !1; + else { + if (62 !== i) return !1; + n = !0; + } + for (e.kind = 'scalar', e.result = ''; 0 !== i; ) + if ( + 43 === (i = e.input.charCodeAt(++e.position)) || + 45 === i + ) + 1 === a + ? (a = 43 === i ? 3 : 2) + : b(e, 'repeat of a chomping mode identifier'); + else { + if ( + !( + (o = 48 <= (s = i) && s <= 57 ? s - 48 : -1) >= + 0 + ) + ) + break; + 0 === o + ? b( + e, + 'bad explicit indentation width of a block scalar; it cannot be less than one' + ) + : g + ? b( + e, + 'repeat of an indentation width identifier' + ) + : ((l = t + o - 1), (g = !0)); + } + if (d(i)) { + do { + i = e.input.charCodeAt(++e.position); + } while (d(i)); + if (35 === i) + do { + i = e.input.charCodeAt(++e.position); + } while (!p(i) && 0 !== i); + } + for (; 0 !== i; ) { + for ( + K(e), + e.lineIndent = 0, + i = e.input.charCodeAt(e.position); + (!g || e.lineIndent < l) && 32 === i; + + ) + e.lineIndent++, + (i = e.input.charCodeAt(++e.position)); + if ( + (!g && e.lineIndent > l && (l = e.lineIndent), p(i)) + ) + u++; + else { + if (e.lineIndent < l) { + 3 === a + ? (e.result += A.repeat('\n', c ? 1 + u : u)) + : 1 === a && c && (e.result += '\n'); + break; + } + for ( + n + ? d(i) + ? ((h = !0), + (e.result += A.repeat('\n', c ? 1 + u : u))) + : h + ? ((h = !1), + (e.result += A.repeat('\n', u + 1))) + : 0 === u + ? c && (e.result += ' ') + : (e.result += A.repeat('\n', u)) + : (e.result += A.repeat('\n', c ? 1 + u : u)), + c = !0, + g = !0, + u = 0, + r = e.position; + !p(i) && 0 !== i; + + ) + i = e.input.charCodeAt(++e.position); + k(e, r, e.position, !1); + } + } + return !0; + })(e, h)) || + (function (e, t) { + var r, A, n; + if (39 !== (r = e.input.charCodeAt(e.position))) + return !1; + for ( + e.kind = 'scalar', + e.result = '', + e.position++, + A = n = e.position; + 0 !== (r = e.input.charCodeAt(e.position)); + + ) + if (39 === r) { + if ( + (k(e, A, e.position, !0), + 39 !== (r = e.input.charCodeAt(++e.position))) + ) + return !0; + (A = e.position), e.position++, (n = e.position); + } else + p(r) + ? (k(e, A, n, !0), + x(e, M(e, !1, t)), + (A = n = e.position)) + : e.position === e.lineStart && R(e) + ? b( + e, + 'unexpected end of the document within a single quoted scalar' + ) + : (e.position++, (n = e.position)); + b( + e, + 'unexpected end of the stream within a single quoted scalar' + ); + })(e, h) || + (function (e, t) { + var r, A, n, o, i, s, a; + if (34 !== (s = e.input.charCodeAt(e.position))) + return !1; + for ( + e.kind = 'scalar', + e.result = '', + e.position++, + r = A = e.position; + 0 !== (s = e.input.charCodeAt(e.position)); + + ) { + if (34 === s) + return k(e, r, e.position, !0), e.position++, !0; + if (92 === s) { + if ( + (k(e, r, e.position, !0), + p((s = e.input.charCodeAt(++e.position)))) + ) + M(e, !1, t); + else if (s < 256 && y[s]) + (e.result += m[s]), e.position++; + else if ( + (i = + 120 === (a = s) + ? 2 + : 117 === a + ? 4 + : 85 === a + ? 8 + : 0) > 0 + ) { + for (n = i, o = 0; n > 0; n--) + (i = I((s = e.input.charCodeAt(++e.position)))) >= + 0 + ? (o = (o << 4) + i) + : b(e, 'expected hexadecimal character'); + (e.result += B(o)), e.position++; + } else b(e, 'unknown escape sequence'); + r = A = e.position; + } else + p(s) + ? (k(e, r, A, !0), + x(e, M(e, !1, t)), + (r = A = e.position)) + : e.position === e.lineStart && R(e) + ? b( + e, + 'unexpected end of the document within a double quoted scalar' + ) + : (e.position++, (A = e.position)); + } + b( + e, + 'unexpected end of the stream within a double quoted scalar' + ); + })(e, h) + ? (D = !0) + : !(function (e) { + var t, r, A; + if (42 !== (A = e.input.charCodeAt(e.position))) + return !1; + for ( + A = e.input.charCodeAt(++e.position), + t = e.position; + 0 !== A && !C(A) && !f(A); + + ) + A = e.input.charCodeAt(++e.position); + return ( + e.position === t && + b( + e, + 'name of an alias node must contain at least one character' + ), + (r = e.input.slice(t, e.position)), + e.anchorMap.hasOwnProperty(r) || + b(e, 'unidentified alias "' + r + '"'), + (e.result = e.anchorMap[r]), + M(e, !0, -1), + !0 + ); + })(e) + ? (function (e, t, r) { + var A, + n, + o, + i, + s, + a, + c, + g, + l = e.kind, + u = e.result; + if ( + C((g = e.input.charCodeAt(e.position))) || + f(g) || + 35 === g || + 38 === g || + 42 === g || + 33 === g || + 124 === g || + 62 === g || + 39 === g || + 34 === g || + 37 === g || + 64 === g || + 96 === g + ) + return !1; + if ( + (63 === g || 45 === g) && + (C((A = e.input.charCodeAt(e.position + 1))) || + (r && f(A))) + ) + return !1; + for ( + e.kind = 'scalar', + e.result = '', + n = o = e.position, + i = !1; + 0 !== g; + + ) { + if (58 === g) { + if ( + C((A = e.input.charCodeAt(e.position + 1))) || + (r && f(A)) + ) + break; + } else if (35 === g) { + if (C(e.input.charCodeAt(e.position - 1))) break; + } else { + if ( + (e.position === e.lineStart && R(e)) || + (r && f(g)) + ) + break; + if (p(g)) { + if ( + ((s = e.line), + (a = e.lineStart), + (c = e.lineIndent), + M(e, !1, -1), + e.lineIndent >= t) + ) { + (i = !0), + (g = e.input.charCodeAt(e.position)); + continue; + } + (e.position = o), + (e.line = s), + (e.lineStart = a), + (e.lineIndent = c); + break; + } + } + i && + (k(e, n, o, !1), + x(e, e.line - s), + (n = o = e.position), + (i = !1)), + d(g) || (o = e.position + 1), + (g = e.input.charCodeAt(++e.position)); + } + return ( + k(e, n, o, !1), + !!e.result || ((e.kind = l), (e.result = u), !1) + ); + })(e, h, 1 === r) && + ((D = !0), null === e.tag && (e.tag = '?')) + : ((D = !0), + (null === e.tag && null === e.anchor) || + b(e, 'alias node should not have any properties')), + null !== e.anchor && (e.anchorMap[e.anchor] = e.result)) + : 0 === w && (D = c && L(e, E))), + null !== e.tag && '!' !== e.tag) + ) + if ('?' === e.tag) { + for (g = 0, l = e.implicitTypes.length; g < l; g += 1) + if ((u = e.implicitTypes[g]).resolve(e.result)) { + (e.result = u.construct(e.result)), + (e.tag = u.tag), + null !== e.anchor && (e.anchorMap[e.anchor] = e.result); + break; + } + } else + a.call(e.typeMap[e.kind || 'fallback'], e.tag) + ? ((u = e.typeMap[e.kind || 'fallback'][e.tag]), + null !== e.result && + u.kind !== e.kind && + b( + e, + 'unacceptable node kind for !<' + + e.tag + + '> tag; it should be "' + + u.kind + + '", not "' + + e.kind + + '"' + ), + u.resolve(e.result) + ? ((e.result = u.construct(e.result)), + null !== e.anchor && (e.anchorMap[e.anchor] = e.result)) + : b( + e, + 'cannot resolve a node with !<' + + e.tag + + '> explicit tag' + )) + : b(e, 'unknown tag !<' + e.tag + '>'); + return ( + null !== e.listener && e.listener('close', e), + null !== e.tag || null !== e.anchor || D + ); + } + function T(e) { + var t, + r, + A, + n, + o = e.position, + i = !1; + for ( + e.version = null, + e.checkLineBreaks = e.legacy, + e.tagMap = {}, + e.anchorMap = {}; + 0 !== (n = e.input.charCodeAt(e.position)) && + (M(e, !0, -1), + (n = e.input.charCodeAt(e.position)), + !(e.lineIndent > 0 || 37 !== n)); + + ) { + for ( + i = !0, n = e.input.charCodeAt(++e.position), t = e.position; + 0 !== n && !C(n); + + ) + n = e.input.charCodeAt(++e.position); + for ( + A = [], + (r = e.input.slice(t, e.position)).length < 1 && + b( + e, + 'directive name must not be less than one character in length' + ); + 0 !== n; + + ) { + for (; d(n); ) n = e.input.charCodeAt(++e.position); + if (35 === n) { + do { + n = e.input.charCodeAt(++e.position); + } while (0 !== n && !p(n)); + break; + } + if (p(n)) break; + for (t = e.position; 0 !== n && !C(n); ) + n = e.input.charCodeAt(++e.position); + A.push(e.input.slice(t, e.position)); + } + 0 !== n && K(e), + a.call(S, r) + ? S[r](e, r, A) + : v(e, 'unknown document directive "' + r + '"'); + } + M(e, !0, -1), + 0 === e.lineIndent && + 45 === e.input.charCodeAt(e.position) && + 45 === e.input.charCodeAt(e.position + 1) && + 45 === e.input.charCodeAt(e.position + 2) + ? ((e.position += 3), M(e, !0, -1)) + : i && b(e, 'directives end mark is expected'), + U(e, e.lineIndent - 1, 4, !1, !0), + M(e, !0, -1), + e.checkLineBreaks && + g.test(e.input.slice(o, e.position)) && + v(e, 'non-ASCII line breaks are interpreted as content'), + e.documents.push(e.result), + e.position === e.lineStart && R(e) + ? 46 === e.input.charCodeAt(e.position) && + ((e.position += 3), M(e, !0, -1)) + : e.position < e.length - 1 && + b(e, 'end of the stream or a document separator is expected'); + } + function j(e, t) { + (t = t || {}), + 0 !== (e = String(e)).length && + (10 !== e.charCodeAt(e.length - 1) && + 13 !== e.charCodeAt(e.length - 1) && + (e += '\n'), + 65279 === e.charCodeAt(0) && (e = e.slice(1))); + var r = new Q(e, t); + for (r.input += '\0'; 32 === r.input.charCodeAt(r.position); ) + (r.lineIndent += 1), (r.position += 1); + for (; r.position < r.length - 1; ) T(r); + return r.documents; + } + function Y(e, t, r) { + var A, + n, + o = j(e, r); + if ('function' != typeof t) return o; + for (A = 0, n = o.length; A < n; A += 1) t(o[A]); + } + function G(e, t) { + var r = j(e, t); + if (0 !== r.length) { + if (1 === r.length) return r[0]; + throw new n( + 'expected a single document in the stream, but found more' + ); + } + } + (e.exports.loadAll = Y), + (e.exports.load = G), + (e.exports.safeLoadAll = function (e, t, r) { + if ('function' != typeof t) return Y(e, A.extend({ schema: i }, r)); + Y(e, t, A.extend({ schema: i }, r)); + }), + (e.exports.safeLoad = function (e, t) { + return G(e, A.extend({ schema: i }, t)); + }); + }, + 30399: (e, t, r) => { + 'use strict'; + var A = r(28149); + function n(e, t, r, A, n) { + (this.name = e), + (this.buffer = t), + (this.position = r), + (this.line = A), + (this.column = n); + } + (n.prototype.getSnippet = function (e, t) { + var r, n, o, i, s; + if (!this.buffer) return null; + for ( + e = e || 4, t = t || 75, r = '', n = this.position; + n > 0 && + -1 === '\0\r\n…\u2028\u2029'.indexOf(this.buffer.charAt(n - 1)); + + ) + if (((n -= 1), this.position - n > t / 2 - 1)) { + (r = ' ... '), (n += 5); + break; + } + for ( + o = '', i = this.position; + i < this.buffer.length && + -1 === '\0\r\n…\u2028\u2029'.indexOf(this.buffer.charAt(i)); + + ) + if ((i += 1) - this.position > t / 2 - 1) { + (o = ' ... '), (i -= 5); + break; + } + return ( + (s = this.buffer.slice(n, i)), + A.repeat(' ', e) + + r + + s + + o + + '\n' + + A.repeat(' ', e + this.position - n + r.length) + + '^' + ); + }), + (n.prototype.toString = function (e) { + var t, + r = ''; + return ( + this.name && (r += 'in "' + this.name + '" '), + (r += + 'at line ' + (this.line + 1) + ', column ' + (this.column + 1)), + e || ((t = this.getSnippet()) && (r += ':\n' + t)), + r + ); + }), + (e.exports = n); + }, + 8212: (e, t, r) => { + 'use strict'; + var A = r(28149), + n = r(17345), + o = r(81704); + function i(e, t, r) { + var A = []; + return ( + e.include.forEach(function (e) { + r = i(e, t, r); + }), + e[t].forEach(function (e) { + r.forEach(function (t, r) { + t.tag === e.tag && t.kind === e.kind && A.push(r); + }), + r.push(e); + }), + r.filter(function (e, t) { + return -1 === A.indexOf(t); + }) + ); + } + function s(e) { + (this.include = e.include || []), + (this.implicit = e.implicit || []), + (this.explicit = e.explicit || []), + this.implicit.forEach(function (e) { + if (e.loadKind && 'scalar' !== e.loadKind) + throw new n( + 'There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.' + ); + }), + (this.compiledImplicit = i(this, 'implicit', [])), + (this.compiledExplicit = i(this, 'explicit', [])), + (this.compiledTypeMap = (function () { + var e, + t, + r = { scalar: {}, sequence: {}, mapping: {}, fallback: {} }; + function A(e) { + r[e.kind][e.tag] = r.fallback[e.tag] = e; + } + for (e = 0, t = arguments.length; e < t; e += 1) + arguments[e].forEach(A); + return r; + })(this.compiledImplicit, this.compiledExplicit)); + } + (s.DEFAULT = null), + (s.create = function () { + var e, t; + switch (arguments.length) { + case 1: + (e = s.DEFAULT), (t = arguments[0]); + break; + case 2: + (e = arguments[0]), (t = arguments[1]); + break; + default: + throw new n( + 'Wrong number of arguments for Schema.create function' + ); + } + if ( + ((e = A.toArray(e)), + (t = A.toArray(t)), + !e.every(function (e) { + return e instanceof s; + })) + ) + throw new n( + 'Specified list of super schemas (or a single Schema object) contains a non-Schema object.' + ); + if ( + !t.every(function (e) { + return e instanceof o; + }) + ) + throw new n( + 'Specified list of YAML types (or a single Type object) contains a non-Type object.' + ); + return new s({ include: e, explicit: t }); + }), + (e.exports = s); + }, + 8769: (e, t, r) => { + 'use strict'; + var A = r(8212); + e.exports = new A({ include: [r(45247)] }); + }, + 5235: (e, t, r) => { + 'use strict'; + var A = r(8212); + e.exports = A.DEFAULT = new A({ + include: [r(65483)], + explicit: [r(61425), r(61872), r(79982)], + }); + }, + 65483: (e, t, r) => { + 'use strict'; + var A = r(8212); + e.exports = new A({ + include: [r(8769)], + implicit: [r(83516), r(95441)], + explicit: [r(34836), r(6847), r(65173), r(92025)], + }); + }, + 44413: (e, t, r) => { + 'use strict'; + var A = r(8212); + e.exports = new A({ explicit: [r(19952), r(46557), r(90173)] }); + }, + 45247: (e, t, r) => { + 'use strict'; + var A = r(8212); + e.exports = new A({ + include: [r(44413)], + implicit: [r(40188), r(58357), r(82106), r(71945)], + }); + }, + 81704: (e, t, r) => { + 'use strict'; + var A = r(17345), + n = [ + 'kind', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'defaultStyle', + 'styleAliases', + ], + o = ['scalar', 'sequence', 'mapping']; + e.exports = function (e, t) { + var r, i; + if ( + ((t = t || {}), + Object.keys(t).forEach(function (t) { + if (-1 === n.indexOf(t)) + throw new A( + 'Unknown option "' + + t + + '" is met in definition of "' + + e + + '" YAML type.' + ); + }), + (this.tag = e), + (this.kind = t.kind || null), + (this.resolve = + t.resolve || + function () { + return !0; + }), + (this.construct = + t.construct || + function (e) { + return e; + }), + (this.instanceOf = t.instanceOf || null), + (this.predicate = t.predicate || null), + (this.represent = t.represent || null), + (this.defaultStyle = t.defaultStyle || null), + (this.styleAliases = + ((r = t.styleAliases || null), + (i = {}), + null !== r && + Object.keys(r).forEach(function (e) { + r[e].forEach(function (t) { + i[String(t)] = e; + }); + }), + i)), + -1 === o.indexOf(this.kind)) + ) + throw new A( + 'Unknown kind "' + + this.kind + + '" is specified for "' + + e + + '" YAML type.' + ); + }; + }, + 34836: (e, t, r) => { + 'use strict'; + var A; + try { + A = r(64293).Buffer; + } catch (e) {} + var n = r(81704), + o = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + e.exports = new n('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !1; + var t, + r, + A = 0, + n = e.length, + i = o; + for (r = 0; r < n; r++) + if (!((t = i.indexOf(e.charAt(r))) > 64)) { + if (t < 0) return !1; + A += 6; + } + return A % 8 == 0; + }, + construct: function (e) { + var t, + r, + n = e.replace(/[\r\n=]/g, ''), + i = n.length, + s = o, + a = 0, + c = []; + for (t = 0; t < i; t++) + t % 4 == 0 && + t && + (c.push((a >> 16) & 255), + c.push((a >> 8) & 255), + c.push(255 & a)), + (a = (a << 6) | s.indexOf(n.charAt(t))); + return ( + 0 === (r = (i % 4) * 6) + ? (c.push((a >> 16) & 255), + c.push((a >> 8) & 255), + c.push(255 & a)) + : 18 === r + ? (c.push((a >> 10) & 255), c.push((a >> 2) & 255)) + : 12 === r && c.push((a >> 4) & 255), + A ? (A.from ? A.from(c) : new A(c)) : c + ); + }, + predicate: function (e) { + return A && A.isBuffer(e); + }, + represent: function (e) { + var t, + r, + A = '', + n = 0, + i = e.length, + s = o; + for (t = 0; t < i; t++) + t % 3 == 0 && + t && + ((A += s[(n >> 18) & 63]), + (A += s[(n >> 12) & 63]), + (A += s[(n >> 6) & 63]), + (A += s[63 & n])), + (n = (n << 8) + e[t]); + return ( + 0 === (r = i % 3) + ? ((A += s[(n >> 18) & 63]), + (A += s[(n >> 12) & 63]), + (A += s[(n >> 6) & 63]), + (A += s[63 & n])) + : 2 === r + ? ((A += s[(n >> 10) & 63]), + (A += s[(n >> 4) & 63]), + (A += s[(n << 2) & 63]), + (A += s[64])) + : 1 === r && + ((A += s[(n >> 2) & 63]), + (A += s[(n << 4) & 63]), + (A += s[64]), + (A += s[64])), + A + ); + }, + }); + }, + 58357: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !1; + var t = e.length; + return ( + (4 === t && ('true' === e || 'True' === e || 'TRUE' === e)) || + (5 === t && ('false' === e || 'False' === e || 'FALSE' === e)) + ); + }, + construct: function (e) { + return 'true' === e || 'True' === e || 'TRUE' === e; + }, + predicate: function (e) { + return '[object Boolean]' === Object.prototype.toString.call(e); + }, + represent: { + lowercase: function (e) { + return e ? 'true' : 'false'; + }, + uppercase: function (e) { + return e ? 'TRUE' : 'FALSE'; + }, + camelcase: function (e) { + return e ? 'True' : 'False'; + }, + }, + defaultStyle: 'lowercase', + }); + }, + 71945: (e, t, r) => { + 'use strict'; + var A = r(28149), + n = r(81704), + o = new RegExp( + '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$' + ); + var i = /^[-+]?[0-9]+e/; + e.exports = new n('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: function (e) { + return null !== e && !(!o.test(e) || '_' === e[e.length - 1]); + }, + construct: function (e) { + var t, r, A, n; + return ( + (r = '-' === (t = e.replace(/_/g, '').toLowerCase())[0] ? -1 : 1), + (n = []), + '+-'.indexOf(t[0]) >= 0 && (t = t.slice(1)), + '.inf' === t + ? 1 === r + ? Number.POSITIVE_INFINITY + : Number.NEGATIVE_INFINITY + : '.nan' === t + ? NaN + : t.indexOf(':') >= 0 + ? (t.split(':').forEach(function (e) { + n.unshift(parseFloat(e, 10)); + }), + (t = 0), + (A = 1), + n.forEach(function (e) { + (t += e * A), (A *= 60); + }), + r * t) + : r * parseFloat(t, 10) + ); + }, + predicate: function (e) { + return ( + '[object Number]' === Object.prototype.toString.call(e) && + (e % 1 != 0 || A.isNegativeZero(e)) + ); + }, + represent: function (e, t) { + var r; + if (isNaN(e)) + switch (t) { + case 'lowercase': + return '.nan'; + case 'uppercase': + return '.NAN'; + case 'camelcase': + return '.NaN'; + } + else if (Number.POSITIVE_INFINITY === e) + switch (t) { + case 'lowercase': + return '.inf'; + case 'uppercase': + return '.INF'; + case 'camelcase': + return '.Inf'; + } + else if (Number.NEGATIVE_INFINITY === e) + switch (t) { + case 'lowercase': + return '-.inf'; + case 'uppercase': + return '-.INF'; + case 'camelcase': + return '-.Inf'; + } + else if (A.isNegativeZero(e)) return '-0.0'; + return (r = e.toString(10)), i.test(r) ? r.replace('e', '.e') : r; + }, + defaultStyle: 'lowercase', + }); + }, + 82106: (e, t, r) => { + 'use strict'; + var A = r(28149), + n = r(81704); + function o(e) { + return 48 <= e && e <= 55; + } + function i(e) { + return 48 <= e && e <= 57; + } + e.exports = new n('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !1; + var t, + r, + A = e.length, + n = 0, + s = !1; + if (!A) return !1; + if ( + (('-' !== (t = e[n]) && '+' !== t) || (t = e[++n]), '0' === t) + ) { + if (n + 1 === A) return !0; + if ('b' === (t = e[++n])) { + for (n++; n < A; n++) + if ('_' !== (t = e[n])) { + if ('0' !== t && '1' !== t) return !1; + s = !0; + } + return s && '_' !== t; + } + if ('x' === t) { + for (n++; n < A; n++) + if ('_' !== (t = e[n])) { + if ( + !( + (48 <= (r = e.charCodeAt(n)) && r <= 57) || + (65 <= r && r <= 70) || + (97 <= r && r <= 102) + ) + ) + return !1; + s = !0; + } + return s && '_' !== t; + } + for (; n < A; n++) + if ('_' !== (t = e[n])) { + if (!o(e.charCodeAt(n))) return !1; + s = !0; + } + return s && '_' !== t; + } + if ('_' === t) return !1; + for (; n < A; n++) + if ('_' !== (t = e[n])) { + if (':' === t) break; + if (!i(e.charCodeAt(n))) return !1; + s = !0; + } + return ( + !(!s || '_' === t) && + (':' !== t || /^(:[0-5]?[0-9])+$/.test(e.slice(n))) + ); + }, + construct: function (e) { + var t, + r, + A = e, + n = 1, + o = []; + return ( + -1 !== A.indexOf('_') && (A = A.replace(/_/g, '')), + ('-' !== (t = A[0]) && '+' !== t) || + ('-' === t && (n = -1), (t = (A = A.slice(1))[0])), + '0' === A + ? 0 + : '0' === t + ? 'b' === A[1] + ? n * parseInt(A.slice(2), 2) + : 'x' === A[1] + ? n * parseInt(A, 16) + : n * parseInt(A, 8) + : -1 !== A.indexOf(':') + ? (A.split(':').forEach(function (e) { + o.unshift(parseInt(e, 10)); + }), + (A = 0), + (r = 1), + o.forEach(function (e) { + (A += e * r), (r *= 60); + }), + n * A) + : n * parseInt(A, 10) + ); + }, + predicate: function (e) { + return ( + '[object Number]' === Object.prototype.toString.call(e) && + e % 1 == 0 && + !A.isNegativeZero(e) + ); + }, + represent: { + binary: function (e) { + return e >= 0 + ? '0b' + e.toString(2) + : '-0b' + e.toString(2).slice(1); + }, + octal: function (e) { + return e >= 0 + ? '0' + e.toString(8) + : '-0' + e.toString(8).slice(1); + }, + decimal: function (e) { + return e.toString(10); + }, + hexadecimal: function (e) { + return e >= 0 + ? '0x' + e.toString(16).toUpperCase() + : '-0x' + e.toString(16).toUpperCase().slice(1); + }, + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [2, 'bin'], + octal: [8, 'oct'], + decimal: [10, 'dec'], + hexadecimal: [16, 'hex'], + }, + }); + }, + 79982: (e, t, r) => { + 'use strict'; + var A; + try { + A = r( + Object( + (function () { + var e = new Error("Cannot find module 'esprima'"); + throw ((e.code = 'MODULE_NOT_FOUND'), e); + })() + ) + ); + } catch (e) { + 'undefined' != typeof window && (A = window.esprima); + } + var n = r(81704); + e.exports = new n('tag:yaml.org,2002:js/function', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !1; + try { + var t = '(' + e + ')', + r = A.parse(t, { range: !0 }); + return ( + 'Program' === r.type && + 1 === r.body.length && + 'ExpressionStatement' === r.body[0].type && + ('ArrowFunctionExpression' === r.body[0].expression.type || + 'FunctionExpression' === r.body[0].expression.type) + ); + } catch (e) { + return !1; + } + }, + construct: function (e) { + var t, + r = '(' + e + ')', + n = A.parse(r, { range: !0 }), + o = []; + if ( + 'Program' !== n.type || + 1 !== n.body.length || + 'ExpressionStatement' !== n.body[0].type || + ('ArrowFunctionExpression' !== n.body[0].expression.type && + 'FunctionExpression' !== n.body[0].expression.type) + ) + throw new Error('Failed to resolve function'); + return ( + n.body[0].expression.params.forEach(function (e) { + o.push(e.name); + }), + (t = n.body[0].expression.body.range), + 'BlockStatement' === n.body[0].expression.body.type + ? new Function(o, r.slice(t[0] + 1, t[1] - 1)) + : new Function(o, 'return ' + r.slice(t[0], t[1])) + ); + }, + predicate: function (e) { + return '[object Function]' === Object.prototype.toString.call(e); + }, + represent: function (e) { + return e.toString(); + }, + }); + }, + 61872: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:js/regexp', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !1; + if (0 === e.length) return !1; + var t = e, + r = /\/([gim]*)$/.exec(e), + A = ''; + if ('/' === t[0]) { + if ((r && (A = r[1]), A.length > 3)) return !1; + if ('/' !== t[t.length - A.length - 1]) return !1; + } + return !0; + }, + construct: function (e) { + var t = e, + r = /\/([gim]*)$/.exec(e), + A = ''; + return ( + '/' === t[0] && + (r && (A = r[1]), (t = t.slice(1, t.length - A.length - 1))), + new RegExp(t, A) + ); + }, + predicate: function (e) { + return '[object RegExp]' === Object.prototype.toString.call(e); + }, + represent: function (e) { + var t = '/' + e.source + '/'; + return ( + e.global && (t += 'g'), + e.multiline && (t += 'm'), + e.ignoreCase && (t += 'i'), + t + ); + }, + }); + }, + 61425: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:js/undefined', { + kind: 'scalar', + resolve: function () { + return !0; + }, + construct: function () {}, + predicate: function (e) { + return void 0 === e; + }, + represent: function () { + return ''; + }, + }); + }, + 90173: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (e) { + return null !== e ? e : {}; + }, + }); + }, + 95441: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: function (e) { + return '<<' === e || null === e; + }, + }); + }, + 40188: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: function (e) { + if (null === e) return !0; + var t = e.length; + return ( + (1 === t && '~' === e) || + (4 === t && ('null' === e || 'Null' === e || 'NULL' === e)) + ); + }, + construct: function () { + return null; + }, + predicate: function (e) { + return null === e; + }, + represent: { + canonical: function () { + return '~'; + }, + lowercase: function () { + return 'null'; + }, + uppercase: function () { + return 'NULL'; + }, + camelcase: function () { + return 'Null'; + }, + }, + defaultStyle: 'lowercase', + }); + }, + 6847: (e, t, r) => { + 'use strict'; + var A = r(81704), + n = Object.prototype.hasOwnProperty, + o = Object.prototype.toString; + e.exports = new A('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: function (e) { + if (null === e) return !0; + var t, + r, + A, + i, + s, + a = [], + c = e; + for (t = 0, r = c.length; t < r; t += 1) { + if (((A = c[t]), (s = !1), '[object Object]' !== o.call(A))) + return !1; + for (i in A) + if (n.call(A, i)) { + if (s) return !1; + s = !0; + } + if (!s) return !1; + if (-1 !== a.indexOf(i)) return !1; + a.push(i); + } + return !0; + }, + construct: function (e) { + return null !== e ? e : []; + }, + }); + }, + 65173: (e, t, r) => { + 'use strict'; + var A = r(81704), + n = Object.prototype.toString; + e.exports = new A('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: function (e) { + if (null === e) return !0; + var t, + r, + A, + o, + i, + s = e; + for (i = new Array(s.length), t = 0, r = s.length; t < r; t += 1) { + if (((A = s[t]), '[object Object]' !== n.call(A))) return !1; + if (1 !== (o = Object.keys(A)).length) return !1; + i[t] = [o[0], A[o[0]]]; + } + return !0; + }, + construct: function (e) { + if (null === e) return []; + var t, + r, + A, + n, + o, + i = e; + for (o = new Array(i.length), t = 0, r = i.length; t < r; t += 1) + (A = i[t]), (n = Object.keys(A)), (o[t] = [n[0], A[n[0]]]); + return o; + }, + }); + }, + 46557: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (e) { + return null !== e ? e : []; + }, + }); + }, + 92025: (e, t, r) => { + 'use strict'; + var A = r(81704), + n = Object.prototype.hasOwnProperty; + e.exports = new A('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: function (e) { + if (null === e) return !0; + var t, + r = e; + for (t in r) if (n.call(r, t) && null !== r[t]) return !1; + return !0; + }, + construct: function (e) { + return null !== e ? e : {}; + }, + }); + }, + 19952: (e, t, r) => { + 'use strict'; + var A = r(81704); + e.exports = new A('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (e) { + return null !== e ? e : ''; + }, + }); + }, + 83516: (e, t, r) => { + 'use strict'; + var A = r(81704), + n = new RegExp('^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$'), + o = new RegExp( + '^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$' + ); + e.exports = new A('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: function (e) { + return null !== e && (null !== n.exec(e) || null !== o.exec(e)); + }, + construct: function (e) { + var t, + r, + A, + i, + s, + a, + c, + g, + l = 0, + u = null; + if ((null === (t = n.exec(e)) && (t = o.exec(e)), null === t)) + throw new Error('Date resolve error'); + if (((r = +t[1]), (A = +t[2] - 1), (i = +t[3]), !t[4])) + return new Date(Date.UTC(r, A, i)); + if (((s = +t[4]), (a = +t[5]), (c = +t[6]), t[7])) { + for (l = t[7].slice(0, 3); l.length < 3; ) l += '0'; + l = +l; + } + return ( + t[9] && + ((u = 6e4 * (60 * +t[10] + +(t[11] || 0))), + '-' === t[9] && (u = -u)), + (g = new Date(Date.UTC(r, A, i, s, a, c, l))), + u && g.setTime(g.getTime() - u), + g + ); + }, + instanceOf: Date, + represent: function (e) { + return e.toISOString(); + }, + }); + }, + 7427: (e, t) => { + (t.stringify = function e(t) { + if (void 0 === t) return t; + if (t && Buffer.isBuffer(t)) + return JSON.stringify(':base64:' + t.toString('base64')); + if ((t && t.toJSON && (t = t.toJSON()), t && 'object' == typeof t)) { + var r = '', + A = Array.isArray(t); + r = A ? '[' : '{'; + var n = !0; + for (var o in t) { + var i = 'function' == typeof t[o] || (!A && void 0 === t[o]); + Object.hasOwnProperty.call(t, o) && + !i && + (n || (r += ','), + (n = !1), + A + ? null == t[o] + ? (r += 'null') + : (r += e(t[o])) + : void 0 !== t[o] && (r += e(o) + ':' + e(t[o]))); + } + return (r += A ? ']' : '}'); + } + return 'string' == typeof t + ? JSON.stringify(/^:/.test(t) ? ':' + t : t) + : void 0 === t + ? 'null' + : JSON.stringify(t); + }), + (t.parse = function (e) { + return JSON.parse(e, function (e, t) { + return 'string' == typeof t + ? /^:base64:/.test(t) + ? Buffer.from(t.substring(8), 'base64') + : /^:/.test(t) + ? t.substring(1) + : t + : t; + }); + }); + }, + 72515: (e, t, r) => { + 'use strict'; + const A = r(28614), + n = r(7427); + e.exports = class extends A { + constructor(e, t) { + if ( + (super(), + (this.opts = Object.assign( + { + namespace: 'keyv', + serialize: n.stringify, + deserialize: n.parse, + }, + 'string' == typeof e ? { uri: e } : e, + t + )), + !this.opts.store) + ) { + const e = Object.assign({}, this.opts); + this.opts.store = ((e) => { + const t = { + redis: '@keyv/redis', + mongodb: '@keyv/mongo', + mongo: '@keyv/mongo', + sqlite: '@keyv/sqlite', + postgresql: '@keyv/postgres', + postgres: '@keyv/postgres', + mysql: '@keyv/mysql', + }; + if (e.adapter || e.uri) { + const A = e.adapter || /^[^:]*/.exec(e.uri)[0]; + return new (r(89112)(t[A]))(e); + } + return new Map(); + })(e); + } + 'function' == typeof this.opts.store.on && + this.opts.store.on('error', (e) => this.emit('error', e)), + (this.opts.store.namespace = this.opts.namespace); + } + _getKeyPrefix(e) { + return `${this.opts.namespace}:${e}`; + } + get(e, t) { + e = this._getKeyPrefix(e); + const { store: r } = this.opts; + return Promise.resolve() + .then(() => r.get(e)) + .then((e) => + 'string' == typeof e ? this.opts.deserialize(e) : e + ) + .then((r) => { + if (void 0 !== r) { + if (!('number' == typeof r.expires && Date.now() > r.expires)) + return t && t.raw ? r : r.value; + this.delete(e); + } + }); + } + set(e, t, r) { + (e = this._getKeyPrefix(e)), + void 0 === r && (r = this.opts.ttl), + 0 === r && (r = void 0); + const { store: A } = this.opts; + return Promise.resolve() + .then(() => { + const e = 'number' == typeof r ? Date.now() + r : null; + return (t = { value: t, expires: e }), this.opts.serialize(t); + }) + .then((t) => A.set(e, t, r)) + .then(() => !0); + } + delete(e) { + e = this._getKeyPrefix(e); + const { store: t } = this.opts; + return Promise.resolve().then(() => t.delete(e)); + } + clear() { + const { store: e } = this.opts; + return Promise.resolve().then(() => e.clear()); + } + }; + }, + 89112: (e) => { + function t(e) { + var t = new Error("Cannot find module '" + e + "'"); + throw ((t.code = 'MODULE_NOT_FOUND'), t); + } + (t.keys = () => []), (t.resolve = t), (t.id = 89112), (e.exports = t); + }, + 78962: (e, t, r) => { + var A = r(99513)(r(76169), 'DataView'); + e.exports = A; + }, + 72574: (e, t, r) => { + var A = r(31713), + n = r(86688), + o = r(45937), + i = r(5017), + s = r(79457); + function a(e) { + var t = -1, + r = null == e ? 0 : e.length; + for (this.clear(); ++t < r; ) { + var A = e[t]; + this.set(A[0], A[1]); + } + } + (a.prototype.clear = A), + (a.prototype.delete = n), + (a.prototype.get = o), + (a.prototype.has = i), + (a.prototype.set = s), + (e.exports = a); + }, + 29197: (e, t, r) => { + var A = r(14620), + n = r(73682), + o = r(43112), + i = r(90640), + s = r(9380); + function a(e) { + var t = -1, + r = null == e ? 0 : e.length; + for (this.clear(); ++t < r; ) { + var A = e[t]; + this.set(A[0], A[1]); + } + } + (a.prototype.clear = A), + (a.prototype.delete = n), + (a.prototype.get = o), + (a.prototype.has = i), + (a.prototype.set = s), + (e.exports = a); + }, + 63603: (e, t, r) => { + var A = r(99513)(r(76169), 'Map'); + e.exports = A; + }, + 75009: (e, t, r) => { + var A = r(18209), + n = r(89706), + o = r(43786), + i = r(17926), + s = r(87345); + function a(e) { + var t = -1, + r = null == e ? 0 : e.length; + for (this.clear(); ++t < r; ) { + var A = e[t]; + this.set(A[0], A[1]); + } + } + (a.prototype.clear = A), + (a.prototype.delete = n), + (a.prototype.get = o), + (a.prototype.has = i), + (a.prototype.set = s), + (e.exports = a); + }, + 5825: (e, t, r) => { + var A = r(99513)(r(76169), 'Promise'); + e.exports = A; + }, + 43231: (e, t, r) => { + var A = r(99513)(r(76169), 'Set'); + e.exports = A; + }, + 46235: (e, t, r) => { + var A = r(75009), + n = r(74785), + o = r(87760); + function i(e) { + var t = -1, + r = null == e ? 0 : e.length; + for (this.__data__ = new A(); ++t < r; ) this.add(e[t]); + } + (i.prototype.add = i.prototype.push = n), + (i.prototype.has = o), + (e.exports = i); + }, + 22851: (e, t, r) => { + var A = r(29197), + n = r(35678), + o = r(33336), + i = r(97163), + s = r(43737), + a = r(48548); + function c(e) { + var t = (this.__data__ = new A(e)); + this.size = t.size; + } + (c.prototype.clear = n), + (c.prototype.delete = o), + (c.prototype.get = i), + (c.prototype.has = s), + (c.prototype.set = a), + (e.exports = c); + }, + 69976: (e, t, r) => { + var A = r(76169).Symbol; + e.exports = A; + }, + 2740: (e, t, r) => { + var A = r(76169).Uint8Array; + e.exports = A; + }, + 47063: (e, t, r) => { + var A = r(99513)(r(76169), 'WeakMap'); + e.exports = A; + }, + 66636: (e) => { + e.exports = function (e, t, r) { + switch (r.length) { + case 0: + return e.call(t); + case 1: + return e.call(t, r[0]); + case 2: + return e.call(t, r[0], r[1]); + case 3: + return e.call(t, r[0], r[1], r[2]); + } + return e.apply(t, r); + }; + }, + 33326: (e) => { + e.exports = function (e, t) { + for ( + var r = -1, A = null == e ? 0 : e.length; + ++r < A && !1 !== t(e[r], r, e); + + ); + return e; + }; + }, + 9073: (e) => { + e.exports = function (e, t) { + for ( + var r = -1, A = null == e ? 0 : e.length, n = 0, o = []; + ++r < A; + + ) { + var i = e[r]; + t(i, r, e) && (o[n++] = i); + } + return o; + }; + }, + 11886: (e, t, r) => { + var A = r(7089), + n = r(61771), + o = r(82664), + i = r(10667), + s = r(98041), + a = r(32565), + c = Object.prototype.hasOwnProperty; + e.exports = function (e, t) { + var r = o(e), + g = !r && n(e), + l = !r && !g && i(e), + u = !r && !g && !l && a(e), + h = r || g || l || u, + p = h ? A(e.length, String) : [], + d = p.length; + for (var C in e) + (!t && !c.call(e, C)) || + (h && + ('length' == C || + (l && ('offset' == C || 'parent' == C)) || + (u && + ('buffer' == C || + 'byteLength' == C || + 'byteOffset' == C)) || + s(C, d))) || + p.push(C); + return p; + }; + }, + 60783: (e) => { + e.exports = function (e, t) { + for ( + var r = -1, A = null == e ? 0 : e.length, n = Array(A); + ++r < A; + + ) + n[r] = t(e[r], r, e); + return n; + }; + }, + 40945: (e) => { + e.exports = function (e, t) { + for (var r = -1, A = t.length, n = e.length; ++r < A; ) + e[n + r] = t[r]; + return e; + }; + }, + 66054: (e) => { + e.exports = function (e, t, r, A) { + var n = -1, + o = null == e ? 0 : e.length; + for (A && o && (r = e[++n]); ++n < o; ) r = t(r, e[n], n, e); + return r; + }; + }, + 17765: (e) => { + e.exports = function (e, t) { + for (var r = -1, A = null == e ? 0 : e.length; ++r < A; ) + if (t(e[r], r, e)) return !0; + return !1; + }; + }, + 1051: (e) => { + e.exports = function (e) { + return e.split(''); + }; + }, + 11852: (e) => { + var t = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + e.exports = function (e) { + return e.match(t) || []; + }; + }, + 26943: (e, t, r) => { + var A = r(91198), + n = r(71074); + e.exports = function (e, t, r) { + ((void 0 !== r && !n(e[t], r)) || (void 0 === r && !(t in e))) && + A(e, t, r); + }; + }, + 65759: (e, t, r) => { + var A = r(91198), + n = r(71074), + o = Object.prototype.hasOwnProperty; + e.exports = function (e, t, r) { + var i = e[t]; + (o.call(e, t) && n(i, r) && (void 0 !== r || t in e)) || A(e, t, r); + }; + }, + 39836: (e, t, r) => { + var A = r(71074); + e.exports = function (e, t) { + for (var r = e.length; r--; ) if (A(e[r][0], t)) return r; + return -1; + }; + }, + 28628: (e, t, r) => { + var A = r(75182), + n = r(42185); + e.exports = function (e, t) { + return e && A(t, n(t), e); + }; + }, + 78707: (e, t, r) => { + var A = r(75182), + n = r(24887); + e.exports = function (e, t) { + return e && A(t, n(t), e); + }; + }, + 91198: (e, t, r) => { + var A = r(65); + e.exports = function (e, t, r) { + '__proto__' == t && A + ? A(e, t, { + configurable: !0, + enumerable: !0, + value: r, + writable: !0, + }) + : (e[t] = r); + }; + }, + 41076: (e, t, r) => { + var A = r(22851), + n = r(33326), + o = r(65759), + i = r(28628), + s = r(78707), + a = r(64266), + c = r(87229), + g = r(23105), + l = r(60741), + u = r(60753), + h = r(64420), + p = r(79435), + d = r(27908), + C = r(37836), + f = r(88438), + I = r(82664), + E = r(10667), + B = r(13349), + y = r(46778), + m = r(33931), + w = r(42185), + Q = {}; + (Q['[object Arguments]'] = Q['[object Array]'] = Q[ + '[object ArrayBuffer]' + ] = Q['[object DataView]'] = Q['[object Boolean]'] = Q[ + '[object Date]' + ] = Q['[object Float32Array]'] = Q['[object Float64Array]'] = Q[ + '[object Int8Array]' + ] = Q['[object Int16Array]'] = Q['[object Int32Array]'] = Q[ + '[object Map]' + ] = Q['[object Number]'] = Q['[object Object]'] = Q[ + '[object RegExp]' + ] = Q['[object Set]'] = Q['[object String]'] = Q['[object Symbol]'] = Q[ + '[object Uint8Array]' + ] = Q['[object Uint8ClampedArray]'] = Q['[object Uint16Array]'] = Q[ + '[object Uint32Array]' + ] = !0), + (Q['[object Error]'] = Q['[object Function]'] = Q[ + '[object WeakMap]' + ] = !1), + (e.exports = function e(t, r, D, b, v, S) { + var k, + N = 1 & r, + F = 2 & r, + K = 4 & r; + if ((D && (k = v ? D(t, b, v, S) : D(t)), void 0 !== k)) return k; + if (!y(t)) return t; + var M = I(t); + if (M) { + if (((k = d(t)), !N)) return c(t, k); + } else { + var R = p(t), + x = + '[object Function]' == R || '[object GeneratorFunction]' == R; + if (E(t)) return a(t, N); + if ( + '[object Object]' == R || + '[object Arguments]' == R || + (x && !v) + ) { + if (((k = F || x ? {} : f(t)), !N)) + return F ? l(t, s(k, t)) : g(t, i(k, t)); + } else { + if (!Q[R]) return v ? t : {}; + k = C(t, R, N); + } + } + S || (S = new A()); + var L = S.get(t); + if (L) return L; + S.set(t, k), + m(t) + ? t.forEach(function (A) { + k.add(e(A, r, D, A, t, S)); + }) + : B(t) && + t.forEach(function (A, n) { + k.set(n, e(A, r, D, n, t, S)); + }); + var P = K ? (F ? h : u) : F ? keysIn : w, + O = M ? void 0 : P(t); + return ( + n(O || t, function (A, n) { + O && (A = t[(n = A)]), o(k, n, e(A, r, D, n, t, S)); + }), + k + ); + }); + }, + 15178: (e, t, r) => { + var A = r(46778), + n = Object.create, + o = (function () { + function e() {} + return function (t) { + if (!A(t)) return {}; + if (n) return n(t); + e.prototype = t; + var r = new e(); + return (e.prototype = void 0), r; + }; + })(); + e.exports = o; + }, + 93274: (e, t, r) => { + var A = r(40945), + n = r(958); + e.exports = function e(t, r, o, i, s) { + var a = -1, + c = t.length; + for (o || (o = n), s || (s = []); ++a < c; ) { + var g = t[a]; + r > 0 && o(g) + ? r > 1 + ? e(g, r - 1, o, i, s) + : A(s, g) + : i || (s[s.length] = g); + } + return s; + }; + }, + 31689: (e, t, r) => { + var A = r(59907)(); + e.exports = A; + }, + 62164: (e, t, r) => { + var A = r(31689), + n = r(42185); + e.exports = function (e, t) { + return e && A(e, t, n); + }; + }, + 84173: (e, t, r) => { + var A = r(56725), + n = r(49874); + e.exports = function (e, t) { + for (var r = 0, o = (t = A(t, e)).length; null != e && r < o; ) + e = e[n(t[r++])]; + return r && r == o ? e : void 0; + }; + }, + 40104: (e, t, r) => { + var A = r(40945), + n = r(82664); + e.exports = function (e, t, r) { + var o = t(e); + return n(e) ? o : A(o, r(e)); + }; + }, + 52502: (e, t, r) => { + var A = r(69976), + n = r(2854), + o = r(87427), + i = A ? A.toStringTag : void 0; + e.exports = function (e) { + return null == e + ? void 0 === e + ? '[object Undefined]' + : '[object Null]' + : i && i in Object(e) + ? n(e) + : o(e); + }; + }, + 95325: (e) => { + var t = Object.prototype.hasOwnProperty; + e.exports = function (e, r) { + return null != e && t.call(e, r); + }; + }, + 3881: (e) => { + e.exports = function (e, t) { + return null != e && t in Object(e); + }; + }, + 76357: (e, t, r) => { + var A = r(52502), + n = r(38496); + e.exports = function (e) { + return n(e) && '[object Arguments]' == A(e); + }; + }, + 74195: (e, t, r) => { + var A = r(48957), + n = r(38496); + e.exports = function e(t, r, o, i, s) { + return ( + t === r || + (null == t || null == r || (!n(t) && !n(r)) + ? t != t && r != r + : A(t, r, o, i, e, s)) + ); + }; + }, + 48957: (e, t, r) => { + var A = r(22851), + n = r(75500), + o = r(28475), + i = r(50245), + s = r(79435), + a = r(82664), + c = r(10667), + g = r(32565), + l = '[object Object]', + u = Object.prototype.hasOwnProperty; + e.exports = function (e, t, r, h, p, d) { + var C = a(e), + f = a(t), + I = C ? '[object Array]' : s(e), + E = f ? '[object Array]' : s(t), + B = (I = '[object Arguments]' == I ? l : I) == l, + y = (E = '[object Arguments]' == E ? l : E) == l, + m = I == E; + if (m && c(e)) { + if (!c(t)) return !1; + (C = !0), (B = !1); + } + if (m && !B) + return ( + d || (d = new A()), + C || g(e) ? n(e, t, r, h, p, d) : o(e, t, I, r, h, p, d) + ); + if (!(1 & r)) { + var w = B && u.call(e, '__wrapped__'), + Q = y && u.call(t, '__wrapped__'); + if (w || Q) { + var D = w ? e.value() : e, + b = Q ? t.value() : t; + return d || (d = new A()), p(D, b, r, h, d); + } + } + return !!m && (d || (d = new A()), i(e, t, r, h, p, d)); + }; + }, + 55994: (e, t, r) => { + var A = r(79435), + n = r(38496); + e.exports = function (e) { + return n(e) && '[object Map]' == A(e); + }; + }, + 66470: (e, t, r) => { + var A = r(22851), + n = r(74195); + e.exports = function (e, t, r, o) { + var i = r.length, + s = i, + a = !o; + if (null == e) return !s; + for (e = Object(e); i--; ) { + var c = r[i]; + if (a && c[2] ? c[1] !== e[c[0]] : !(c[0] in e)) return !1; + } + for (; ++i < s; ) { + var g = (c = r[i])[0], + l = e[g], + u = c[1]; + if (a && c[2]) { + if (void 0 === l && !(g in e)) return !1; + } else { + var h = new A(); + if (o) var p = o(l, u, g, e, t, h); + if (!(void 0 === p ? n(u, l, 3, o, h) : p)) return !1; + } + } + return !0; + }; + }, + 91686: (e, t, r) => { + var A = r(92533), + n = r(15061), + o = r(46778), + i = r(76384), + s = /^\[object .+?Constructor\]$/, + a = Function.prototype, + c = Object.prototype, + g = a.toString, + l = c.hasOwnProperty, + u = RegExp( + '^' + + g + .call(l) + .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') + .replace( + /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, + '$1.*?' + ) + + '$' + ); + e.exports = function (e) { + return !(!o(e) || n(e)) && (A(e) ? u : s).test(i(e)); + }; + }, + 28612: (e, t, r) => { + var A = r(79435), + n = r(38496); + e.exports = function (e) { + return n(e) && '[object Set]' == A(e); + }; + }, + 98998: (e, t, r) => { + var A = r(52502), + n = r(46369), + o = r(38496), + i = {}; + (i['[object Float32Array]'] = i['[object Float64Array]'] = i[ + '[object Int8Array]' + ] = i['[object Int16Array]'] = i['[object Int32Array]'] = i[ + '[object Uint8Array]' + ] = i['[object Uint8ClampedArray]'] = i['[object Uint16Array]'] = i[ + '[object Uint32Array]' + ] = !0), + (i['[object Arguments]'] = i['[object Array]'] = i[ + '[object ArrayBuffer]' + ] = i['[object Boolean]'] = i['[object DataView]'] = i[ + '[object Date]' + ] = i['[object Error]'] = i['[object Function]'] = i[ + '[object Map]' + ] = i['[object Number]'] = i['[object Object]'] = i[ + '[object RegExp]' + ] = i['[object Set]'] = i['[object String]'] = i[ + '[object WeakMap]' + ] = !1), + (e.exports = function (e) { + return o(e) && n(e.length) && !!i[A(e)]; + }); + }, + 42208: (e, t, r) => { + var A = r(96962), + n = r(90348), + o = r(61977), + i = r(82664), + s = r(7430); + e.exports = function (e) { + return 'function' == typeof e + ? e + : null == e + ? o + : 'object' == typeof e + ? i(e) + ? n(e[0], e[1]) + : A(e) + : s(e); + }; + }, + 50994: (e, t, r) => { + var A = r(89513), + n = r(60657), + o = Object.prototype.hasOwnProperty; + e.exports = function (e) { + if (!A(e)) return n(e); + var t = []; + for (var r in Object(e)) + o.call(e, r) && 'constructor' != r && t.push(r); + return t; + }; + }, + 8372: (e, t, r) => { + var A = r(46778), + n = r(89513), + o = r(95632), + i = Object.prototype.hasOwnProperty; + e.exports = function (e) { + if (!A(e)) return o(e); + var t = n(e), + r = []; + for (var s in e) + ('constructor' != s || (!t && i.call(e, s))) && r.push(s); + return r; + }; + }, + 96962: (e, t, r) => { + var A = r(66470), + n = r(98705), + o = r(12757); + e.exports = function (e) { + var t = n(e); + return 1 == t.length && t[0][2] + ? o(t[0][0], t[0][1]) + : function (r) { + return r === e || A(r, e, t); + }; + }; + }, + 90348: (e, t, r) => { + var A = r(74195), + n = r(44674), + o = r(34878), + i = r(70474), + s = r(20925), + a = r(12757), + c = r(49874); + e.exports = function (e, t) { + return i(e) && s(t) + ? a(c(e), t) + : function (r) { + var i = n(r, e); + return void 0 === i && i === t ? o(r, e) : A(t, i, 3); + }; + }; + }, + 51264: (e, t, r) => { + var A = r(22851), + n = r(26943), + o = r(31689), + i = r(16834), + s = r(46778), + a = r(24887), + c = r(36883); + e.exports = function e(t, r, g, l, u) { + t !== r && + o( + r, + function (o, a) { + if ((u || (u = new A()), s(o))) i(t, r, a, g, e, l, u); + else { + var h = l ? l(c(t, a), o, a + '', t, r, u) : void 0; + void 0 === h && (h = o), n(t, a, h); + } + }, + a + ); + }; + }, + 16834: (e, t, r) => { + var A = r(26943), + n = r(64266), + o = r(58042), + i = r(87229), + s = r(88438), + a = r(61771), + c = r(82664), + g = r(16064), + l = r(10667), + u = r(92533), + h = r(46778), + p = r(11672), + d = r(32565), + C = r(36883), + f = r(36506); + e.exports = function (e, t, r, I, E, B, y) { + var m = C(e, r), + w = C(t, r), + Q = y.get(w); + if (Q) A(e, r, Q); + else { + var D = B ? B(m, w, r + '', e, t, y) : void 0, + b = void 0 === D; + if (b) { + var v = c(w), + S = !v && l(w), + k = !v && !S && d(w); + (D = w), + v || S || k + ? c(m) + ? (D = m) + : g(m) + ? (D = i(m)) + : S + ? ((b = !1), (D = n(w, !0))) + : k + ? ((b = !1), (D = o(w, !0))) + : (D = []) + : p(w) || a(w) + ? ((D = m), a(m) ? (D = f(m)) : (h(m) && !u(m)) || (D = s(w))) + : (b = !1); + } + b && (y.set(w, D), E(D, w, I, B, y), y.delete(w)), A(e, r, D); + } + }; + }, + 72204: (e, t, r) => { + var A = r(35314), + n = r(34878); + e.exports = function (e, t) { + return A(e, t, function (t, r) { + return n(e, r); + }); + }; + }, + 35314: (e, t, r) => { + var A = r(84173), + n = r(10624), + o = r(56725); + e.exports = function (e, t, r) { + for (var i = -1, s = t.length, a = {}; ++i < s; ) { + var c = t[i], + g = A(e, c); + r(g, c) && n(a, o(c, e), g); + } + return a; + }; + }, + 35400: (e) => { + e.exports = function (e) { + return function (t) { + return null == t ? void 0 : t[e]; + }; + }; + }, + 43018: (e, t, r) => { + var A = r(84173); + e.exports = function (e) { + return function (t) { + return A(t, e); + }; + }; + }, + 51587: (e) => { + e.exports = function (e) { + return function (t) { + return null == e ? void 0 : e[t]; + }; + }; + }, + 30383: (e, t, r) => { + var A = r(61977), + n = r(44322), + o = r(3111); + e.exports = function (e, t) { + return o(n(e, t, A), e + ''); + }; + }, + 10624: (e, t, r) => { + var A = r(65759), + n = r(56725), + o = r(98041), + i = r(46778), + s = r(49874); + e.exports = function (e, t, r, a) { + if (!i(e)) return e; + for ( + var c = -1, g = (t = n(t, e)).length, l = g - 1, u = e; + null != u && ++c < g; + + ) { + var h = s(t[c]), + p = r; + if (c != l) { + var d = u[h]; + void 0 === (p = a ? a(d, h, u) : void 0) && + (p = i(d) ? d : o(t[c + 1]) ? [] : {}); + } + A(u, h, p), (u = u[h]); + } + return e; + }; + }, + 4899: (e, t, r) => { + var A = r(4967), + n = r(65), + o = r(61977), + i = n + ? function (e, t) { + return n(e, 'toString', { + configurable: !0, + enumerable: !1, + value: A(t), + writable: !0, + }); + } + : o; + e.exports = i; + }, + 27708: (e) => { + e.exports = function (e, t, r) { + var A = -1, + n = e.length; + t < 0 && (t = -t > n ? 0 : n + t), + (r = r > n ? n : r) < 0 && (r += n), + (n = t > r ? 0 : (r - t) >>> 0), + (t >>>= 0); + for (var o = Array(n); ++A < n; ) o[A] = e[A + t]; + return o; + }; + }, + 7089: (e) => { + e.exports = function (e, t) { + for (var r = -1, A = Array(e); ++r < e; ) A[r] = t(r); + return A; + }; + }, + 35: (e, t, r) => { + var A = r(69976), + n = r(60783), + o = r(82664), + i = r(65558), + s = A ? A.prototype : void 0, + a = s ? s.toString : void 0; + e.exports = function e(t) { + if ('string' == typeof t) return t; + if (o(t)) return n(t, e) + ''; + if (i(t)) return a ? a.call(t) : ''; + var r = t + ''; + return '0' == r && 1 / t == -1 / 0 ? '-0' : r; + }; + }, + 73635: (e) => { + e.exports = function (e) { + return function (t) { + return e(t); + }; + }; + }, + 18290: (e, t, r) => { + var A = r(60783); + e.exports = function (e, t) { + return A(t, function (t) { + return e[t]; + }); + }; + }, + 93022: (e) => { + e.exports = function (e, t) { + return e.has(t); + }; + }, + 56725: (e, t, r) => { + var A = r(82664), + n = r(70474), + o = r(8689), + i = r(33580); + e.exports = function (e, t) { + return A(e) ? e : n(e, t) ? [e] : o(i(e)); + }; + }, + 92568: (e, t, r) => { + var A = r(27708); + e.exports = function (e, t, r) { + var n = e.length; + return (r = void 0 === r ? n : r), !t && r >= n ? e : A(e, t, r); + }; + }, + 76255: (e, t, r) => { + var A = r(2740); + e.exports = function (e) { + var t = new e.constructor(e.byteLength); + return new A(t).set(new A(e)), t; + }; + }, + 64266: (e, t, r) => { + e = r.nmd(e); + var A = r(76169), + n = t && !t.nodeType && t, + o = n && e && !e.nodeType && e, + i = o && o.exports === n ? A.Buffer : void 0, + s = i ? i.allocUnsafe : void 0; + e.exports = function (e, t) { + if (t) return e.slice(); + var r = e.length, + A = s ? s(r) : new e.constructor(r); + return e.copy(A), A; + }; + }, + 63749: (e, t, r) => { + var A = r(76255); + e.exports = function (e, t) { + var r = t ? A(e.buffer) : e.buffer; + return new e.constructor(r, e.byteOffset, e.byteLength); + }; + }, + 41705: (e) => { + var t = /\w*$/; + e.exports = function (e) { + var r = new e.constructor(e.source, t.exec(e)); + return (r.lastIndex = e.lastIndex), r; + }; + }, + 25791: (e, t, r) => { + var A = r(69976), + n = A ? A.prototype : void 0, + o = n ? n.valueOf : void 0; + e.exports = function (e) { + return o ? Object(o.call(e)) : {}; + }; + }, + 58042: (e, t, r) => { + var A = r(76255); + e.exports = function (e, t) { + var r = t ? A(e.buffer) : e.buffer; + return new e.constructor(r, e.byteOffset, e.length); + }; + }, + 87229: (e) => { + e.exports = function (e, t) { + var r = -1, + A = e.length; + for (t || (t = Array(A)); ++r < A; ) t[r] = e[r]; + return t; + }; + }, + 75182: (e, t, r) => { + var A = r(65759), + n = r(91198); + e.exports = function (e, t, r, o) { + var i = !r; + r || (r = {}); + for (var s = -1, a = t.length; ++s < a; ) { + var c = t[s], + g = o ? o(r[c], e[c], c, r, e) : void 0; + void 0 === g && (g = e[c]), i ? n(r, c, g) : A(r, c, g); + } + return r; + }; + }, + 23105: (e, t, r) => { + var A = r(75182), + n = r(68727); + e.exports = function (e, t) { + return A(e, n(e), t); + }; + }, + 60741: (e, t, r) => { + var A = r(75182), + n = r(35368); + e.exports = function (e, t) { + return A(e, n(e), t); + }; + }, + 14429: (e, t, r) => { + var A = r(76169)['__core-js_shared__']; + e.exports = A; + }, + 27913: (e, t, r) => { + var A = r(30383), + n = r(33193); + e.exports = function (e) { + return A(function (t, r) { + var A = -1, + o = r.length, + i = o > 1 ? r[o - 1] : void 0, + s = o > 2 ? r[2] : void 0; + for ( + i = e.length > 3 && 'function' == typeof i ? (o--, i) : void 0, + s && n(r[0], r[1], s) && ((i = o < 3 ? void 0 : i), (o = 1)), + t = Object(t); + ++A < o; + + ) { + var a = r[A]; + a && e(t, a, A, i); + } + return t; + }); + }; + }, + 59907: (e) => { + e.exports = function (e) { + return function (t, r, A) { + for (var n = -1, o = Object(t), i = A(t), s = i.length; s--; ) { + var a = i[e ? s : ++n]; + if (!1 === r(o[a], a, o)) break; + } + return t; + }; + }; + }, + 56989: (e, t, r) => { + var A = r(92568), + n = r(93024), + o = r(30475), + i = r(33580); + e.exports = function (e) { + return function (t) { + t = i(t); + var r = n(t) ? o(t) : void 0, + s = r ? r[0] : t.charAt(0), + a = r ? A(r, 1).join('') : t.slice(1); + return s[e]() + a; + }; + }; + }, + 30369: (e, t, r) => { + var A = r(66054), + n = r(68968), + o = r(97684), + i = RegExp("['’]", 'g'); + e.exports = function (e) { + return function (t) { + return A(o(n(t).replace(i, '')), e, ''); + }; + }; + }, + 69922: (e, t, r) => { + var A = r(51587)({ + À: 'A', + Á: 'A', + Â: 'A', + Ã: 'A', + Ä: 'A', + Å: 'A', + à: 'a', + á: 'a', + â: 'a', + ã: 'a', + ä: 'a', + å: 'a', + Ç: 'C', + ç: 'c', + Ð: 'D', + ð: 'd', + È: 'E', + É: 'E', + Ê: 'E', + Ë: 'E', + è: 'e', + é: 'e', + ê: 'e', + ë: 'e', + Ì: 'I', + Í: 'I', + Î: 'I', + Ï: 'I', + ì: 'i', + í: 'i', + î: 'i', + ï: 'i', + Ñ: 'N', + ñ: 'n', + Ò: 'O', + Ó: 'O', + Ô: 'O', + Õ: 'O', + Ö: 'O', + Ø: 'O', + ò: 'o', + ó: 'o', + ô: 'o', + õ: 'o', + ö: 'o', + ø: 'o', + Ù: 'U', + Ú: 'U', + Û: 'U', + Ü: 'U', + ù: 'u', + ú: 'u', + û: 'u', + ü: 'u', + Ý: 'Y', + ý: 'y', + ÿ: 'y', + Æ: 'Ae', + æ: 'ae', + Þ: 'Th', + þ: 'th', + ß: 'ss', + Ā: 'A', + Ă: 'A', + Ą: 'A', + ā: 'a', + ă: 'a', + ą: 'a', + Ć: 'C', + Ĉ: 'C', + Ċ: 'C', + Č: 'C', + ć: 'c', + ĉ: 'c', + ċ: 'c', + č: 'c', + Ď: 'D', + Đ: 'D', + ď: 'd', + đ: 'd', + Ē: 'E', + Ĕ: 'E', + Ė: 'E', + Ę: 'E', + Ě: 'E', + ē: 'e', + ĕ: 'e', + ė: 'e', + ę: 'e', + ě: 'e', + Ĝ: 'G', + Ğ: 'G', + Ġ: 'G', + Ģ: 'G', + ĝ: 'g', + ğ: 'g', + ġ: 'g', + ģ: 'g', + Ĥ: 'H', + Ħ: 'H', + ĥ: 'h', + ħ: 'h', + Ĩ: 'I', + Ī: 'I', + Ĭ: 'I', + Į: 'I', + İ: 'I', + ĩ: 'i', + ī: 'i', + ĭ: 'i', + į: 'i', + ı: 'i', + Ĵ: 'J', + ĵ: 'j', + Ķ: 'K', + ķ: 'k', + ĸ: 'k', + Ĺ: 'L', + Ļ: 'L', + Ľ: 'L', + Ŀ: 'L', + Ł: 'L', + ĺ: 'l', + ļ: 'l', + ľ: 'l', + ŀ: 'l', + ł: 'l', + Ń: 'N', + Ņ: 'N', + Ň: 'N', + Ŋ: 'N', + ń: 'n', + ņ: 'n', + ň: 'n', + ŋ: 'n', + Ō: 'O', + Ŏ: 'O', + Ő: 'O', + ō: 'o', + ŏ: 'o', + ő: 'o', + Ŕ: 'R', + Ŗ: 'R', + Ř: 'R', + ŕ: 'r', + ŗ: 'r', + ř: 'r', + Ś: 'S', + Ŝ: 'S', + Ş: 'S', + Š: 'S', + ś: 's', + ŝ: 's', + ş: 's', + š: 's', + Ţ: 'T', + Ť: 'T', + Ŧ: 'T', + ţ: 't', + ť: 't', + ŧ: 't', + Ũ: 'U', + Ū: 'U', + Ŭ: 'U', + Ů: 'U', + Ű: 'U', + Ų: 'U', + ũ: 'u', + ū: 'u', + ŭ: 'u', + ů: 'u', + ű: 'u', + ų: 'u', + Ŵ: 'W', + ŵ: 'w', + Ŷ: 'Y', + ŷ: 'y', + Ÿ: 'Y', + Ź: 'Z', + Ż: 'Z', + Ž: 'Z', + ź: 'z', + ż: 'z', + ž: 'z', + IJ: 'IJ', + ij: 'ij', + Œ: 'Oe', + œ: 'oe', + ʼn: "'n", + ſ: 's', + }); + e.exports = A; + }, + 65: (e, t, r) => { + var A = r(99513), + n = (function () { + try { + var e = A(Object, 'defineProperty'); + return e({}, '', {}), e; + } catch (e) {} + })(); + e.exports = n; + }, + 75500: (e, t, r) => { + var A = r(46235), + n = r(17765), + o = r(93022); + e.exports = function (e, t, r, i, s, a) { + var c = 1 & r, + g = e.length, + l = t.length; + if (g != l && !(c && l > g)) return !1; + var u = a.get(e); + if (u && a.get(t)) return u == t; + var h = -1, + p = !0, + d = 2 & r ? new A() : void 0; + for (a.set(e, t), a.set(t, e); ++h < g; ) { + var C = e[h], + f = t[h]; + if (i) var I = c ? i(f, C, h, t, e, a) : i(C, f, h, e, t, a); + if (void 0 !== I) { + if (I) continue; + p = !1; + break; + } + if (d) { + if ( + !n(t, function (e, t) { + if (!o(d, t) && (C === e || s(C, e, r, i, a))) + return d.push(t); + }) + ) { + p = !1; + break; + } + } else if (C !== f && !s(C, f, r, i, a)) { + p = !1; + break; + } + } + return a.delete(e), a.delete(t), p; + }; + }, + 28475: (e, t, r) => { + var A = r(69976), + n = r(2740), + o = r(71074), + i = r(75500), + s = r(7877), + a = r(7442), + c = A ? A.prototype : void 0, + g = c ? c.valueOf : void 0; + e.exports = function (e, t, r, A, c, l, u) { + switch (r) { + case '[object DataView]': + if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset) + return !1; + (e = e.buffer), (t = t.buffer); + case '[object ArrayBuffer]': + return !(e.byteLength != t.byteLength || !l(new n(e), new n(t))); + case '[object Boolean]': + case '[object Date]': + case '[object Number]': + return o(+e, +t); + case '[object Error]': + return e.name == t.name && e.message == t.message; + case '[object RegExp]': + case '[object String]': + return e == t + ''; + case '[object Map]': + var h = s; + case '[object Set]': + var p = 1 & A; + if ((h || (h = a), e.size != t.size && !p)) return !1; + var d = u.get(e); + if (d) return d == t; + (A |= 2), u.set(e, t); + var C = i(h(e), h(t), A, c, l, u); + return u.delete(e), C; + case '[object Symbol]': + if (g) return g.call(e) == g.call(t); + } + return !1; + }; + }, + 50245: (e, t, r) => { + var A = r(60753), + n = Object.prototype.hasOwnProperty; + e.exports = function (e, t, r, o, i, s) { + var a = 1 & r, + c = A(e), + g = c.length; + if (g != A(t).length && !a) return !1; + for (var l = g; l--; ) { + var u = c[l]; + if (!(a ? u in t : n.call(t, u))) return !1; + } + var h = s.get(e); + if (h && s.get(t)) return h == t; + var p = !0; + s.set(e, t), s.set(t, e); + for (var d = a; ++l < g; ) { + var C = e[(u = c[l])], + f = t[u]; + if (o) var I = a ? o(f, C, u, t, e, s) : o(C, f, u, e, t, s); + if (!(void 0 === I ? C === f || i(C, f, r, o, s) : I)) { + p = !1; + break; + } + d || (d = 'constructor' == u); + } + if (p && !d) { + var E = e.constructor, + B = t.constructor; + E == B || + !('constructor' in e) || + !('constructor' in t) || + ('function' == typeof E && + E instanceof E && + 'function' == typeof B && + B instanceof B) || + (p = !1); + } + return s.delete(e), s.delete(t), p; + }; + }, + 87298: (e, t, r) => { + var A = r(54690), + n = r(44322), + o = r(3111); + e.exports = function (e) { + return o(n(e, void 0, A), e + ''); + }; + }, + 68399: (e) => { + var t = + 'object' == typeof global && + global && + global.Object === Object && + global; + e.exports = t; + }, + 60753: (e, t, r) => { + var A = r(40104), + n = r(68727), + o = r(42185); + e.exports = function (e) { + return A(e, o, n); + }; + }, + 64420: (e, t, r) => { + var A = r(40104), + n = r(35368), + o = r(24887); + e.exports = function (e) { + return A(e, o, n); + }; + }, + 59253: (e, t, r) => { + var A = r(69448); + e.exports = function (e, t) { + var r = e.__data__; + return A(t) ? r['string' == typeof t ? 'string' : 'hash'] : r.map; + }; + }, + 98705: (e, t, r) => { + var A = r(20925), + n = r(42185); + e.exports = function (e) { + for (var t = n(e), r = t.length; r--; ) { + var o = t[r], + i = e[o]; + t[r] = [o, i, A(i)]; + } + return t; + }; + }, + 99513: (e, t, r) => { + var A = r(91686), + n = r(98054); + e.exports = function (e, t) { + var r = n(e, t); + return A(r) ? r : void 0; + }; + }, + 41181: (e, t, r) => { + var A = r(64309)(Object.getPrototypeOf, Object); + e.exports = A; + }, + 2854: (e, t, r) => { + var A = r(69976), + n = Object.prototype, + o = n.hasOwnProperty, + i = n.toString, + s = A ? A.toStringTag : void 0; + e.exports = function (e) { + var t = o.call(e, s), + r = e[s]; + try { + e[s] = void 0; + var A = !0; + } catch (e) {} + var n = i.call(e); + return A && (t ? (e[s] = r) : delete e[s]), n; + }; + }, + 68727: (e, t, r) => { + var A = r(9073), + n = r(62162), + o = Object.prototype.propertyIsEnumerable, + i = Object.getOwnPropertySymbols, + s = i + ? function (e) { + return null == e + ? [] + : ((e = Object(e)), + A(i(e), function (t) { + return o.call(e, t); + })); + } + : n; + e.exports = s; + }, + 35368: (e, t, r) => { + var A = r(40945), + n = r(41181), + o = r(68727), + i = r(62162), + s = Object.getOwnPropertySymbols + ? function (e) { + for (var t = []; e; ) A(t, o(e)), (e = n(e)); + return t; + } + : i; + e.exports = s; + }, + 79435: (e, t, r) => { + var A = r(78962), + n = r(63603), + o = r(5825), + i = r(43231), + s = r(47063), + a = r(52502), + c = r(76384), + g = c(A), + l = c(n), + u = c(o), + h = c(i), + p = c(s), + d = a; + ((A && '[object DataView]' != d(new A(new ArrayBuffer(1)))) || + (n && '[object Map]' != d(new n())) || + (o && '[object Promise]' != d(o.resolve())) || + (i && '[object Set]' != d(new i())) || + (s && '[object WeakMap]' != d(new s()))) && + (d = function (e) { + var t = a(e), + r = '[object Object]' == t ? e.constructor : void 0, + A = r ? c(r) : ''; + if (A) + switch (A) { + case g: + return '[object DataView]'; + case l: + return '[object Map]'; + case u: + return '[object Promise]'; + case h: + return '[object Set]'; + case p: + return '[object WeakMap]'; + } + return t; + }), + (e.exports = d); + }, + 98054: (e) => { + e.exports = function (e, t) { + return null == e ? void 0 : e[t]; + }; + }, + 71507: (e, t, r) => { + var A = r(56725), + n = r(61771), + o = r(82664), + i = r(98041), + s = r(46369), + a = r(49874); + e.exports = function (e, t, r) { + for (var c = -1, g = (t = A(t, e)).length, l = !1; ++c < g; ) { + var u = a(t[c]); + if (!(l = null != e && r(e, u))) break; + e = e[u]; + } + return l || ++c != g + ? l + : !!(g = null == e ? 0 : e.length) && + s(g) && + i(u, g) && + (o(e) || n(e)); + }; + }, + 93024: (e) => { + var t = RegExp( + '[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]' + ); + e.exports = function (e) { + return t.test(e); + }; + }, + 60466: (e) => { + var t = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + e.exports = function (e) { + return t.test(e); + }; + }, + 31713: (e, t, r) => { + var A = r(52437); + e.exports = function () { + (this.__data__ = A ? A(null) : {}), (this.size = 0); + }; + }, + 86688: (e) => { + e.exports = function (e) { + var t = this.has(e) && delete this.__data__[e]; + return (this.size -= t ? 1 : 0), t; + }; + }, + 45937: (e, t, r) => { + var A = r(52437), + n = Object.prototype.hasOwnProperty; + e.exports = function (e) { + var t = this.__data__; + if (A) { + var r = t[e]; + return '__lodash_hash_undefined__' === r ? void 0 : r; + } + return n.call(t, e) ? t[e] : void 0; + }; + }, + 5017: (e, t, r) => { + var A = r(52437), + n = Object.prototype.hasOwnProperty; + e.exports = function (e) { + var t = this.__data__; + return A ? void 0 !== t[e] : n.call(t, e); + }; + }, + 79457: (e, t, r) => { + var A = r(52437); + e.exports = function (e, t) { + var r = this.__data__; + return ( + (this.size += this.has(e) ? 0 : 1), + (r[e] = A && void 0 === t ? '__lodash_hash_undefined__' : t), + this + ); + }; + }, + 27908: (e) => { + var t = Object.prototype.hasOwnProperty; + e.exports = function (e) { + var r = e.length, + A = new e.constructor(r); + return ( + r && + 'string' == typeof e[0] && + t.call(e, 'index') && + ((A.index = e.index), (A.input = e.input)), + A + ); + }; + }, + 37836: (e, t, r) => { + var A = r(76255), + n = r(63749), + o = r(41705), + i = r(25791), + s = r(58042); + e.exports = function (e, t, r) { + var a = e.constructor; + switch (t) { + case '[object ArrayBuffer]': + return A(e); + case '[object Boolean]': + case '[object Date]': + return new a(+e); + case '[object DataView]': + return n(e, r); + case '[object Float32Array]': + case '[object Float64Array]': + case '[object Int8Array]': + case '[object Int16Array]': + case '[object Int32Array]': + case '[object Uint8Array]': + case '[object Uint8ClampedArray]': + case '[object Uint16Array]': + case '[object Uint32Array]': + return s(e, r); + case '[object Map]': + return new a(); + case '[object Number]': + case '[object String]': + return new a(e); + case '[object RegExp]': + return o(e); + case '[object Set]': + return new a(); + case '[object Symbol]': + return i(e); + } + }; + }, + 88438: (e, t, r) => { + var A = r(15178), + n = r(41181), + o = r(89513); + e.exports = function (e) { + return 'function' != typeof e.constructor || o(e) ? {} : A(n(e)); + }; + }, + 958: (e, t, r) => { + var A = r(69976), + n = r(61771), + o = r(82664), + i = A ? A.isConcatSpreadable : void 0; + e.exports = function (e) { + return o(e) || n(e) || !!(i && e && e[i]); + }; + }, + 98041: (e) => { + var t = /^(?:0|[1-9]\d*)$/; + e.exports = function (e, r) { + var A = typeof e; + return ( + !!(r = null == r ? 9007199254740991 : r) && + ('number' == A || ('symbol' != A && t.test(e))) && + e > -1 && + e % 1 == 0 && + e < r + ); + }; + }, + 33193: (e, t, r) => { + var A = r(71074), + n = r(41929), + o = r(98041), + i = r(46778); + e.exports = function (e, t, r) { + if (!i(r)) return !1; + var s = typeof t; + return ( + !!('number' == s + ? n(r) && o(t, r.length) + : 'string' == s && t in r) && A(r[t], e) + ); + }; + }, + 70474: (e, t, r) => { + var A = r(82664), + n = r(65558), + o = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + i = /^\w*$/; + e.exports = function (e, t) { + if (A(e)) return !1; + var r = typeof e; + return ( + !( + 'number' != r && + 'symbol' != r && + 'boolean' != r && + null != e && + !n(e) + ) || + i.test(e) || + !o.test(e) || + (null != t && e in Object(t)) + ); + }; + }, + 69448: (e) => { + e.exports = function (e) { + var t = typeof e; + return 'string' == t || + 'number' == t || + 'symbol' == t || + 'boolean' == t + ? '__proto__' !== e + : null === e; + }; + }, + 15061: (e, t, r) => { + var A, + n = r(14429), + o = (A = /[^.]+$/.exec((n && n.keys && n.keys.IE_PROTO) || '')) + ? 'Symbol(src)_1.' + A + : ''; + e.exports = function (e) { + return !!o && o in e; + }; + }, + 89513: (e) => { + var t = Object.prototype; + e.exports = function (e) { + var r = e && e.constructor; + return e === (('function' == typeof r && r.prototype) || t); + }; + }, + 20925: (e, t, r) => { + var A = r(46778); + e.exports = function (e) { + return e == e && !A(e); + }; + }, + 82262: (e) => { + e.exports = function (e) { + for (var t, r = []; !(t = e.next()).done; ) r.push(t.value); + return r; + }; + }, + 14620: (e) => { + e.exports = function () { + (this.__data__ = []), (this.size = 0); + }; + }, + 73682: (e, t, r) => { + var A = r(39836), + n = Array.prototype.splice; + e.exports = function (e) { + var t = this.__data__, + r = A(t, e); + return ( + !(r < 0) && + (r == t.length - 1 ? t.pop() : n.call(t, r, 1), --this.size, !0) + ); + }; + }, + 43112: (e, t, r) => { + var A = r(39836); + e.exports = function (e) { + var t = this.__data__, + r = A(t, e); + return r < 0 ? void 0 : t[r][1]; + }; + }, + 90640: (e, t, r) => { + var A = r(39836); + e.exports = function (e) { + return A(this.__data__, e) > -1; + }; + }, + 9380: (e, t, r) => { + var A = r(39836); + e.exports = function (e, t) { + var r = this.__data__, + n = A(r, e); + return n < 0 ? (++this.size, r.push([e, t])) : (r[n][1] = t), this; + }; + }, + 18209: (e, t, r) => { + var A = r(72574), + n = r(29197), + o = r(63603); + e.exports = function () { + (this.size = 0), + (this.__data__ = { + hash: new A(), + map: new (o || n)(), + string: new A(), + }); + }; + }, + 89706: (e, t, r) => { + var A = r(59253); + e.exports = function (e) { + var t = A(this, e).delete(e); + return (this.size -= t ? 1 : 0), t; + }; + }, + 43786: (e, t, r) => { + var A = r(59253); + e.exports = function (e) { + return A(this, e).get(e); + }; + }, + 17926: (e, t, r) => { + var A = r(59253); + e.exports = function (e) { + return A(this, e).has(e); + }; + }, + 87345: (e, t, r) => { + var A = r(59253); + e.exports = function (e, t) { + var r = A(this, e), + n = r.size; + return r.set(e, t), (this.size += r.size == n ? 0 : 1), this; + }; + }, + 7877: (e) => { + e.exports = function (e) { + var t = -1, + r = Array(e.size); + return ( + e.forEach(function (e, A) { + r[++t] = [A, e]; + }), + r + ); + }; + }, + 12757: (e) => { + e.exports = function (e, t) { + return function (r) { + return null != r && r[e] === t && (void 0 !== t || e in Object(r)); + }; + }; + }, + 31948: (e, t, r) => { + var A = r(74499); + e.exports = function (e) { + var t = A(e, function (e) { + return 500 === r.size && r.clear(), e; + }), + r = t.cache; + return t; + }; + }, + 52437: (e, t, r) => { + var A = r(99513)(Object, 'create'); + e.exports = A; + }, + 60657: (e, t, r) => { + var A = r(64309)(Object.keys, Object); + e.exports = A; + }, + 95632: (e) => { + e.exports = function (e) { + var t = []; + if (null != e) for (var r in Object(e)) t.push(r); + return t; + }; + }, + 26391: (e, t, r) => { + e = r.nmd(e); + var A = r(68399), + n = t && !t.nodeType && t, + o = n && e && !e.nodeType && e, + i = o && o.exports === n && A.process, + s = (function () { + try { + var e = o && o.require && o.require('util').types; + return e || (i && i.binding && i.binding('util')); + } catch (e) {} + })(); + e.exports = s; + }, + 87427: (e) => { + var t = Object.prototype.toString; + e.exports = function (e) { + return t.call(e); + }; + }, + 64309: (e) => { + e.exports = function (e, t) { + return function (r) { + return e(t(r)); + }; + }; + }, + 44322: (e, t, r) => { + var A = r(66636), + n = Math.max; + e.exports = function (e, t, r) { + return ( + (t = n(void 0 === t ? e.length - 1 : t, 0)), + function () { + for ( + var o = arguments, i = -1, s = n(o.length - t, 0), a = Array(s); + ++i < s; + + ) + a[i] = o[t + i]; + i = -1; + for (var c = Array(t + 1); ++i < t; ) c[i] = o[i]; + return (c[t] = r(a)), A(e, this, c); + } + ); + }; + }, + 76169: (e, t, r) => { + var A = r(68399), + n = 'object' == typeof self && self && self.Object === Object && self, + o = A || n || Function('return this')(); + e.exports = o; + }, + 36883: (e) => { + e.exports = function (e, t) { + if ( + ('constructor' !== t || 'function' != typeof e[t]) && + '__proto__' != t + ) + return e[t]; + }; + }, + 74785: (e) => { + e.exports = function (e) { + return this.__data__.set(e, '__lodash_hash_undefined__'), this; + }; + }, + 87760: (e) => { + e.exports = function (e) { + return this.__data__.has(e); + }; + }, + 7442: (e) => { + e.exports = function (e) { + var t = -1, + r = Array(e.size); + return ( + e.forEach(function (e) { + r[++t] = e; + }), + r + ); + }; + }, + 3111: (e, t, r) => { + var A = r(4899), + n = r(19908)(A); + e.exports = n; + }, + 19908: (e) => { + var t = Date.now; + e.exports = function (e) { + var r = 0, + A = 0; + return function () { + var n = t(), + o = 16 - (n - A); + if (((A = n), o > 0)) { + if (++r >= 800) return arguments[0]; + } else r = 0; + return e.apply(void 0, arguments); + }; + }; + }, + 35678: (e, t, r) => { + var A = r(29197); + e.exports = function () { + (this.__data__ = new A()), (this.size = 0); + }; + }, + 33336: (e) => { + e.exports = function (e) { + var t = this.__data__, + r = t.delete(e); + return (this.size = t.size), r; + }; + }, + 97163: (e) => { + e.exports = function (e) { + return this.__data__.get(e); + }; + }, + 43737: (e) => { + e.exports = function (e) { + return this.__data__.has(e); + }; + }, + 48548: (e, t, r) => { + var A = r(29197), + n = r(63603), + o = r(75009); + e.exports = function (e, t) { + var r = this.__data__; + if (r instanceof A) { + var i = r.__data__; + if (!n || i.length < 199) + return i.push([e, t]), (this.size = ++r.size), this; + r = this.__data__ = new o(i); + } + return r.set(e, t), (this.size = r.size), this; + }; + }, + 30475: (e, t, r) => { + var A = r(1051), + n = r(93024), + o = r(297); + e.exports = function (e) { + return n(e) ? o(e) : A(e); + }; + }, + 8689: (e, t, r) => { + var A = r(31948), + n = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, + o = /\\(\\)?/g, + i = A(function (e) { + var t = []; + return ( + 46 === e.charCodeAt(0) && t.push(''), + e.replace(n, function (e, r, A, n) { + t.push(A ? n.replace(o, '$1') : r || e); + }), + t + ); + }); + e.exports = i; + }, + 49874: (e, t, r) => { + var A = r(65558); + e.exports = function (e) { + if ('string' == typeof e || A(e)) return e; + var t = e + ''; + return '0' == t && 1 / e == -1 / 0 ? '-0' : t; + }; + }, + 76384: (e) => { + var t = Function.prototype.toString; + e.exports = function (e) { + if (null != e) { + try { + return t.call(e); + } catch (e) {} + try { + return e + ''; + } catch (e) {} + } + return ''; + }; + }, + 297: (e) => { + var t = '[\\ud800-\\udfff]', + r = '[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]', + A = '\\ud83c[\\udffb-\\udfff]', + n = '[^\\ud800-\\udfff]', + o = '(?:\\ud83c[\\udde6-\\uddff]){2}', + i = '[\\ud800-\\udbff][\\udc00-\\udfff]', + s = '(?:' + r + '|' + A + ')' + '?', + a = + '[\\ufe0e\\ufe0f]?' + + s + + ('(?:\\u200d(?:' + + [n, o, i].join('|') + + ')[\\ufe0e\\ufe0f]?' + + s + + ')*'), + c = '(?:' + [n + r + '?', r, o, i, t].join('|') + ')', + g = RegExp(A + '(?=' + A + ')|' + c + a, 'g'); + e.exports = function (e) { + return e.match(g) || []; + }; + }, + 89887: (e) => { + var t = + '\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', + r = '[' + t + ']', + A = '\\d+', + n = '[\\u2700-\\u27bf]', + o = '[a-z\\xdf-\\xf6\\xf8-\\xff]', + i = + '[^\\ud800-\\udfff' + + t + + A + + '\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde]', + s = '(?:\\ud83c[\\udde6-\\uddff]){2}', + a = '[\\ud800-\\udbff][\\udc00-\\udfff]', + c = '[A-Z\\xc0-\\xd6\\xd8-\\xde]', + g = '(?:' + o + '|' + i + ')', + l = '(?:' + c + '|' + i + ')', + u = + '(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?', + h = + '[\\ufe0e\\ufe0f]?' + + u + + ('(?:\\u200d(?:' + + ['[^\\ud800-\\udfff]', s, a].join('|') + + ')[\\ufe0e\\ufe0f]?' + + u + + ')*'), + p = '(?:' + [n, s, a].join('|') + ')' + h, + d = RegExp( + [ + c + + '?' + + o + + "+(?:['’](?:d|ll|m|re|s|t|ve))?(?=" + + [r, c, '$'].join('|') + + ')', + l + + "+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=" + + [r, c + g, '$'].join('|') + + ')', + c + '?' + g + "+(?:['’](?:d|ll|m|re|s|t|ve))?", + c + "+(?:['’](?:D|LL|M|RE|S|T|VE))?", + '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', + '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', + A, + p, + ].join('|'), + 'g' + ); + e.exports = function (e) { + return e.match(d) || []; + }; + }, + 89170: (e, t, r) => { + var A = r(61814), + n = r(30369)(function (e, t, r) { + return (t = t.toLowerCase()), e + (r ? A(t) : t); + }); + e.exports = n; + }, + 61814: (e, t, r) => { + var A = r(33580), + n = r(72609); + e.exports = function (e) { + return n(A(e).toLowerCase()); + }; + }, + 82558: (e, t, r) => { + var A = r(41076); + e.exports = function (e) { + return A(e, 5); + }; + }, + 26052: (e, t, r) => { + var A = r(41076); + e.exports = function (e, t) { + return A(e, 5, (t = 'function' == typeof t ? t : void 0)); + }; + }, + 4967: (e) => { + e.exports = function (e) { + return function () { + return e; + }; + }; + }, + 68968: (e, t, r) => { + var A = r(69922), + n = r(33580), + o = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g, + i = RegExp('[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]', 'g'); + e.exports = function (e) { + return (e = n(e)) && e.replace(o, A).replace(i, ''); + }; + }, + 71074: (e) => { + e.exports = function (e, t) { + return e === t || (e != e && t != t); + }; + }, + 54690: (e, t, r) => { + var A = r(93274); + e.exports = function (e) { + return (null == e ? 0 : e.length) ? A(e, 1) : []; + }; + }, + 44674: (e, t, r) => { + var A = r(84173); + e.exports = function (e, t, r) { + var n = null == e ? void 0 : A(e, t); + return void 0 === n ? r : n; + }; + }, + 15215: (e, t, r) => { + var A = r(95325), + n = r(71507); + e.exports = function (e, t) { + return null != e && n(e, t, A); + }; + }, + 34878: (e, t, r) => { + var A = r(3881), + n = r(71507); + e.exports = function (e, t) { + return null != e && n(e, t, A); + }; + }, + 61977: (e) => { + e.exports = function (e) { + return e; + }; + }, + 61771: (e, t, r) => { + var A = r(76357), + n = r(38496), + o = Object.prototype, + i = o.hasOwnProperty, + s = o.propertyIsEnumerable, + a = A( + (function () { + return arguments; + })() + ) + ? A + : function (e) { + return n(e) && i.call(e, 'callee') && !s.call(e, 'callee'); + }; + e.exports = a; + }, + 82664: (e) => { + var t = Array.isArray; + e.exports = t; + }, + 41929: (e, t, r) => { + var A = r(92533), + n = r(46369); + e.exports = function (e) { + return null != e && n(e.length) && !A(e); + }; + }, + 16064: (e, t, r) => { + var A = r(41929), + n = r(38496); + e.exports = function (e) { + return n(e) && A(e); + }; + }, + 10667: (e, t, r) => { + e = r.nmd(e); + var A = r(76169), + n = r(88988), + o = t && !t.nodeType && t, + i = o && e && !e.nodeType && e, + s = i && i.exports === o ? A.Buffer : void 0, + a = (s ? s.isBuffer : void 0) || n; + e.exports = a; + }, + 92533: (e, t, r) => { + var A = r(52502), + n = r(46778); + e.exports = function (e) { + if (!n(e)) return !1; + var t = A(e); + return ( + '[object Function]' == t || + '[object GeneratorFunction]' == t || + '[object AsyncFunction]' == t || + '[object Proxy]' == t + ); + }; + }, + 46369: (e) => { + e.exports = function (e) { + return ( + 'number' == typeof e && + e > -1 && + e % 1 == 0 && + e <= 9007199254740991 + ); + }; + }, + 13349: (e, t, r) => { + var A = r(55994), + n = r(73635), + o = r(26391), + i = o && o.isMap, + s = i ? n(i) : A; + e.exports = s; + }, + 46778: (e) => { + e.exports = function (e) { + var t = typeof e; + return null != e && ('object' == t || 'function' == t); + }; + }, + 38496: (e) => { + e.exports = function (e) { + return null != e && 'object' == typeof e; + }; + }, + 11672: (e, t, r) => { + var A = r(52502), + n = r(41181), + o = r(38496), + i = Function.prototype, + s = Object.prototype, + a = i.toString, + c = s.hasOwnProperty, + g = a.call(Object); + e.exports = function (e) { + if (!o(e) || '[object Object]' != A(e)) return !1; + var t = n(e); + if (null === t) return !0; + var r = c.call(t, 'constructor') && t.constructor; + return 'function' == typeof r && r instanceof r && a.call(r) == g; + }; + }, + 33931: (e, t, r) => { + var A = r(28612), + n = r(73635), + o = r(26391), + i = o && o.isSet, + s = i ? n(i) : A; + e.exports = s; + }, + 221: (e, t, r) => { + var A = r(52502), + n = r(82664), + o = r(38496); + e.exports = function (e) { + return ( + 'string' == typeof e || (!n(e) && o(e) && '[object String]' == A(e)) + ); + }; + }, + 65558: (e, t, r) => { + var A = r(52502), + n = r(38496); + e.exports = function (e) { + return 'symbol' == typeof e || (n(e) && '[object Symbol]' == A(e)); + }; + }, + 32565: (e, t, r) => { + var A = r(98998), + n = r(73635), + o = r(26391), + i = o && o.isTypedArray, + s = i ? n(i) : A; + e.exports = s; + }, + 42185: (e, t, r) => { + var A = r(11886), + n = r(50994), + o = r(41929); + e.exports = function (e) { + return o(e) ? A(e) : n(e); + }; + }, + 24887: (e, t, r) => { + var A = r(11886), + n = r(8372), + o = r(41929); + e.exports = function (e) { + return o(e) ? A(e, !0) : n(e); + }; + }, + 5253: (e, t, r) => { + var A = r(91198), + n = r(62164), + o = r(42208); + e.exports = function (e, t) { + var r = {}; + return ( + (t = o(t, 3)), + n(e, function (e, n, o) { + A(r, t(e, n, o), e); + }), + r + ); + }; + }, + 89612: (e, t, r) => { + var A = r(91198), + n = r(62164), + o = r(42208); + e.exports = function (e, t) { + var r = {}; + return ( + (t = o(t, 3)), + n(e, function (e, n, o) { + A(r, n, t(e, n, o)); + }), + r + ); + }; + }, + 74499: (e, t, r) => { + var A = r(75009); + function n(e, t) { + if ('function' != typeof e || (null != t && 'function' != typeof t)) + throw new TypeError('Expected a function'); + var r = function () { + var A = arguments, + n = t ? t.apply(this, A) : A[0], + o = r.cache; + if (o.has(n)) return o.get(n); + var i = e.apply(this, A); + return (r.cache = o.set(n, i) || o), i; + }; + return (r.cache = new (n.Cache || A)()), r; + } + (n.Cache = A), (e.exports = n); + }, + 80305: (e, t, r) => { + var A = r(51264), + n = r(27913)(function (e, t, r) { + A(e, t, r); + }); + e.exports = n; + }, + 75130: (e, t, r) => { + var A = r(72204), + n = r(87298)(function (e, t) { + return null == e ? {} : A(e, t); + }); + e.exports = n; + }, + 7430: (e, t, r) => { + var A = r(35400), + n = r(43018), + o = r(70474), + i = r(49874); + e.exports = function (e) { + return o(e) ? A(i(e)) : n(e); + }; + }, + 81534: (e, t, r) => { + var A = r(10624); + e.exports = function (e, t, r) { + return null == e ? e : A(e, t, r); + }; + }, + 36494: (e, t, r) => { + var A = r(30369)(function (e, t, r) { + return e + (r ? '_' : '') + t.toLowerCase(); + }); + e.exports = A; + }, + 62162: (e) => { + e.exports = function () { + return []; + }; + }, + 88988: (e) => { + e.exports = function () { + return !1; + }; + }, + 78700: (e, t, r) => { + var A = r(69976), + n = r(87229), + o = r(79435), + i = r(41929), + s = r(221), + a = r(82262), + c = r(7877), + g = r(7442), + l = r(30475), + u = r(24448), + h = A ? A.iterator : void 0; + e.exports = function (e) { + if (!e) return []; + if (i(e)) return s(e) ? l(e) : n(e); + if (h && e[h]) return a(e[h]()); + var t = o(e); + return ('[object Map]' == t ? c : '[object Set]' == t ? g : u)(e); + }; + }, + 36506: (e, t, r) => { + var A = r(75182), + n = r(24887); + e.exports = function (e) { + return A(e, n(e)); + }; + }, + 33580: (e, t, r) => { + var A = r(35); + e.exports = function (e) { + return null == e ? '' : A(e); + }; + }, + 72609: (e, t, r) => { + var A = r(56989)('toUpperCase'); + e.exports = A; + }, + 24448: (e, t, r) => { + var A = r(18290), + n = r(42185); + e.exports = function (e) { + return null == e ? [] : A(e, n(e)); + }; + }, + 97684: (e, t, r) => { + var A = r(11852), + n = r(60466), + o = r(33580), + i = r(89887); + e.exports = function (e, t, r) { + return ( + (e = o(e)), + void 0 === (t = r ? void 0 : t) + ? n(e) + ? i(e) + : A(e) + : e.match(t) || [] + ); + }; + }, + 55737: (e) => { + 'use strict'; + e.exports = (e) => { + const t = {}; + for (const [r, A] of Object.entries(e)) t[r.toLowerCase()] = A; + return t; + }; + }, + 46227: (e, t, r) => { + 'use strict'; + const A = r(35747), + n = r(85622), + { promisify: o } = r(31669), + i = r(95584).satisfies(process.version, '>=10.12.0'), + s = (e) => { + if ('win32' === process.platform) { + if (/[<>:"|?*]/.test(e.replace(n.parse(e).root, ''))) { + const t = new Error('Path contains invalid characters: ' + e); + throw ((t.code = 'EINVAL'), t); + } + } + }, + a = (e) => ({ ...{ mode: 511, fs: A }, ...e }), + c = (e) => { + const t = new Error(`operation not permitted, mkdir '${e}'`); + return ( + (t.code = 'EPERM'), + (t.errno = -4048), + (t.path = e), + (t.syscall = 'mkdir'), + t + ); + }; + (e.exports = async (e, t) => { + s(e), (t = a(t)); + const r = o(t.fs.mkdir), + g = o(t.fs.stat); + if (i && t.fs.mkdir === A.mkdir) { + const A = n.resolve(e); + return await r(A, { mode: t.mode, recursive: !0 }), A; + } + const l = async (e) => { + try { + return await r(e, t.mode), e; + } catch (t) { + if ('EPERM' === t.code) throw t; + if ('ENOENT' === t.code) { + if (n.dirname(e) === e) throw c(e); + if (t.message.includes('null bytes')) throw t; + return await l(n.dirname(e)), l(e); + } + try { + if (!(await g(e)).isDirectory()) + throw new Error('The path is not a directory'); + } catch (e) { + throw t; + } + return e; + } + }; + return l(n.resolve(e)); + }), + (e.exports.sync = (e, t) => { + if ((s(e), (t = a(t)), i && t.fs.mkdirSync === A.mkdirSync)) { + const r = n.resolve(e); + return A.mkdirSync(r, { mode: t.mode, recursive: !0 }), r; + } + const r = (e) => { + try { + t.fs.mkdirSync(e, t.mode); + } catch (A) { + if ('EPERM' === A.code) throw A; + if ('ENOENT' === A.code) { + if (n.dirname(e) === e) throw c(e); + if (A.message.includes('null bytes')) throw A; + return r(n.dirname(e)), r(e); + } + try { + if (!t.fs.statSync(e).isDirectory()) + throw new Error('The path is not a directory'); + } catch (e) { + throw A; + } + } + return e; + }; + return r(n.resolve(e)); + }); + }, + 55598: (e, t, r) => { + 'use strict'; + const A = r(92413).PassThrough, + n = Array.prototype.slice; + function o(e, t) { + if (Array.isArray(e)) + for (let r = 0, A = e.length; r < A; r++) e[r] = o(e[r], t); + else { + if ( + (!e._readableState && e.pipe && (e = e.pipe(A(t))), + !e._readableState || !e.pause || !e.pipe) + ) + throw new Error('Only readable stream can be merged.'); + e.pause(); + } + return e; + } + e.exports = function () { + const e = []; + let t = !1; + const r = n.call(arguments); + let i = r[r.length - 1]; + i && !Array.isArray(i) && null == i.pipe ? r.pop() : (i = {}); + const s = !1 !== i.end; + null == i.objectMode && (i.objectMode = !0); + null == i.highWaterMark && (i.highWaterMark = 65536); + const a = A(i); + function c() { + for (let t = 0, r = arguments.length; t < r; t++) + e.push(o(arguments[t], i)); + return g(), this; + } + function g() { + if (t) return; + t = !0; + let r = e.shift(); + if (!r) return void process.nextTick(l); + Array.isArray(r) || (r = [r]); + let A = r.length + 1; + function n() { + --A > 0 || ((t = !1), g()); + } + function o(e) { + function t() { + e.removeListener('merge2UnpipeEnd', t), + e.removeListener('end', t), + n(); + } + if (e._readableState.endEmitted) return n(); + e.on('merge2UnpipeEnd', t), + e.on('end', t), + e.pipe(a, { end: !1 }), + e.resume(); + } + for (let e = 0; e < r.length; e++) o(r[e]); + n(); + } + function l() { + return (t = !1), a.emit('queueDrain'), s && a.end(); + } + a.setMaxListeners(0), + (a.add = c), + a.on('unpipe', function (e) { + e.emit('merge2UnpipeEnd'); + }), + r.length && c.apply(null, r); + return a; + }; + }, + 2401: (e, t, r) => { + 'use strict'; + const A = r(31669), + n = r(12235), + o = r(54722), + i = r(3598), + s = (e) => 'string' == typeof e && ('' === e || './' === e), + a = (e, t, r) => { + (t = [].concat(t)), (e = [].concat(e)); + let A = new Set(), + n = new Set(), + i = new Set(), + s = 0, + a = (e) => { + i.add(e.output), r && r.onResult && r.onResult(e); + }; + for (let i = 0; i < t.length; i++) { + let c = o(String(t[i]), { ...r, onResult: a }, !0), + g = c.state.negated || c.state.negatedExtglob; + g && s++; + for (let t of e) { + let e = c(t, !0); + (g ? !e.isMatch : e.isMatch) && + (g ? A.add(e.output) : (A.delete(e.output), n.add(e.output))); + } + } + let c = (s === t.length ? [...i] : [...n]).filter((e) => !A.has(e)); + if (r && 0 === c.length) { + if (!0 === r.failglob) + throw new Error(`No matches found for "${t.join(', ')}"`); + if (!0 === r.nonull || !0 === r.nullglob) + return r.unescape ? t.map((e) => e.replace(/\\/g, '')) : t; + } + return c; + }; + (a.match = a), + (a.matcher = (e, t) => o(e, t)), + (a.any = a.isMatch = (e, t, r) => o(t, r)(e)), + (a.not = (e, t, r = {}) => { + t = [].concat(t).map(String); + let A = new Set(), + n = [], + o = a(e, t, { + ...r, + onResult: (e) => { + r.onResult && r.onResult(e), n.push(e.output); + }, + }); + for (let e of n) o.includes(e) || A.add(e); + return [...A]; + }), + (a.contains = (e, t, r) => { + if ('string' != typeof e) + throw new TypeError(`Expected a string: "${A.inspect(e)}"`); + if (Array.isArray(t)) return t.some((t) => a.contains(e, t, r)); + if ('string' == typeof t) { + if (s(e) || s(t)) return !1; + if ( + e.includes(t) || + (e.startsWith('./') && e.slice(2).includes(t)) + ) + return !0; + } + return a.isMatch(e, t, { ...r, contains: !0 }); + }), + (a.matchKeys = (e, t, r) => { + if (!i.isObject(e)) + throw new TypeError( + 'Expected the first argument to be an object' + ); + let A = a(Object.keys(e), t, r), + n = {}; + for (let t of A) n[t] = e[t]; + return n; + }), + (a.some = (e, t, r) => { + let A = [].concat(e); + for (let e of [].concat(t)) { + let t = o(String(e), r); + if (A.some((e) => t(e))) return !0; + } + return !1; + }), + (a.every = (e, t, r) => { + let A = [].concat(e); + for (let e of [].concat(t)) { + let t = o(String(e), r); + if (!A.every((e) => t(e))) return !1; + } + return !0; + }), + (a.all = (e, t, r) => { + if ('string' != typeof e) + throw new TypeError(`Expected a string: "${A.inspect(e)}"`); + return [].concat(t).every((t) => o(t, r)(e)); + }), + (a.capture = (e, t, r) => { + let A = i.isWindows(r), + n = o + .makeRe(String(e), { ...r, capture: !0 }) + .exec(A ? i.toPosixSlashes(t) : t); + if (n) return n.slice(1).map((e) => (void 0 === e ? '' : e)); + }), + (a.makeRe = (...e) => o.makeRe(...e)), + (a.scan = (...e) => o.scan(...e)), + (a.parse = (e, t) => { + let r = []; + for (let A of [].concat(e || [])) + for (let e of n(String(A), t)) r.push(o.parse(e, t)); + return r; + }), + (a.braces = (e, t) => { + if ('string' != typeof e) throw new TypeError('Expected a string'); + return (t && !0 === t.nobrace) || !/\{.*\}/.test(e) ? [e] : n(e, t); + }), + (a.braceExpand = (e, t) => { + if ('string' != typeof e) throw new TypeError('Expected a string'); + return a.braces(e, { ...t, expand: !0 }); + }), + (e.exports = a); + }, + 65007: (e) => { + 'use strict'; + const t = [ + 'destroy', + 'setTimeout', + 'socket', + 'headers', + 'trailers', + 'rawHeaders', + 'statusCode', + 'httpVersion', + 'httpVersionMinor', + 'httpVersionMajor', + 'rawTrailers', + 'statusMessage', + ]; + e.exports = (e, r) => { + const A = new Set(Object.keys(e).concat(t)); + for (const t of A) + t in r || (r[t] = 'function' == typeof e[t] ? e[t].bind(e) : e[t]); + }; + }, + 33527: (e) => { + 'use strict'; + const t = [ + 'aborted', + 'complete', + 'headers', + 'httpVersion', + 'httpVersionMinor', + 'httpVersionMajor', + 'method', + 'rawHeaders', + 'rawTrailers', + 'setTimeout', + 'socket', + 'statusCode', + 'statusMessage', + 'trailers', + 'url', + ]; + e.exports = (e, r) => { + if (r._readableState.autoDestroy) + throw new Error( + 'The second stream must have the `autoDestroy` option set to `false`' + ); + const A = new Set(Object.keys(e).concat(t)), + n = {}; + for (const t of A) + t in r || + (n[t] = { + get() { + const r = e[t]; + return 'function' == typeof r ? r.bind(e) : r; + }, + set(r) { + e[t] = r; + }, + enumerable: !0, + configurable: !1, + }); + return ( + Object.defineProperties(r, n), + e.once('aborted', () => { + r.destroy(), r.emit('aborted'); + }), + e.once('close', () => { + e.complete && r.readable + ? r.once('end', () => { + r.emit('close'); + }) + : r.emit('close'); + }), + r + ); + }; + }, + 19793: (e, t, r) => { + 'use strict'; + const A = 'undefined' == typeof URL ? r(78835).URL : URL, + n = (e, t) => + t.some((t) => (t instanceof RegExp ? t.test(e) : t === e)), + o = (e, t) => { + if ( + ((t = { + defaultProtocol: 'http:', + normalizeProtocol: !0, + forceHttp: !1, + forceHttps: !1, + stripAuthentication: !0, + stripHash: !1, + stripWWW: !0, + removeQueryParameters: [/^utm_\w+/i], + removeTrailingSlash: !0, + removeDirectoryIndex: !1, + sortQueryParameters: !0, + ...t, + }), + Reflect.has(t, 'normalizeHttps')) + ) + throw new Error( + 'options.normalizeHttps is renamed to options.forceHttp' + ); + if (Reflect.has(t, 'normalizeHttp')) + throw new Error( + 'options.normalizeHttp is renamed to options.forceHttps' + ); + if (Reflect.has(t, 'stripFragment')) + throw new Error( + 'options.stripFragment is renamed to options.stripHash' + ); + if (((e = e.trim()), /^data:/i.test(e))) + return ((e, { stripHash: t }) => { + const r = e.match(/^data:(.*?),(.*?)(?:#(.*))?$/); + if (!r) throw new Error('Invalid URL: ' + e); + const A = r[1].split(';'), + n = r[2], + o = t ? '' : r[3]; + let i = !1; + 'base64' === A[A.length - 1] && (A.pop(), (i = !0)); + const s = (A.shift() || '').toLowerCase(), + a = [ + ...A.map((e) => { + let [t, r = ''] = e.split('=').map((e) => e.trim()); + return 'charset' === t && + ((r = r.toLowerCase()), 'us-ascii' === r) + ? '' + : `${t}${r ? '=' + r : ''}`; + }).filter(Boolean), + ]; + return ( + i && a.push('base64'), + (0 !== a.length || (s && 'text/plain' !== s)) && a.unshift(s), + `data:${a.join(';')},${i ? n.trim() : n}${o ? '#' + o : ''}` + ); + })(e, t); + const r = e.startsWith('//'); + (!r && /^\.*\//.test(e)) || + (e = e.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, t.defaultProtocol)); + const o = new A(e); + if (t.forceHttp && t.forceHttps) + throw new Error( + 'The `forceHttp` and `forceHttps` options cannot be used together' + ); + if ( + (t.forceHttp && 'https:' === o.protocol && (o.protocol = 'http:'), + t.forceHttps && 'http:' === o.protocol && (o.protocol = 'https:'), + t.stripAuthentication && ((o.username = ''), (o.password = '')), + t.stripHash && (o.hash = ''), + o.pathname && + (o.pathname = o.pathname.replace(/((?!:).|^)\/{2,}/g, (e, t) => + /^(?!\/)/g.test(t) ? t + '/' : '/' + )), + o.pathname && (o.pathname = decodeURI(o.pathname)), + !0 === t.removeDirectoryIndex && + (t.removeDirectoryIndex = [/^index\.[a-z]+$/]), + Array.isArray(t.removeDirectoryIndex) && + t.removeDirectoryIndex.length > 0) + ) { + let e = o.pathname.split('/'); + const r = e[e.length - 1]; + n(r, t.removeDirectoryIndex) && + ((e = e.slice(0, e.length - 1)), + (o.pathname = e.slice(1).join('/') + '/')); + } + if ( + (o.hostname && + ((o.hostname = o.hostname.replace(/\.$/, '')), + t.stripWWW && + /^www\.([a-z\-\d]{2,63})\.([a-z.]{2,5})$/.test(o.hostname) && + (o.hostname = o.hostname.replace(/^www\./, ''))), + Array.isArray(t.removeQueryParameters)) + ) + for (const e of [...o.searchParams.keys()]) + n(e, t.removeQueryParameters) && o.searchParams.delete(e); + return ( + t.sortQueryParameters && o.searchParams.sort(), + t.removeTrailingSlash && + (o.pathname = o.pathname.replace(/\/$/, '')), + (e = o.toString()), + (!t.removeTrailingSlash && '/' !== o.pathname) || + '' !== o.hash || + (e = e.replace(/\/$/, '')), + r && !t.normalizeProtocol && (e = e.replace(/^http:\/\//, '//')), + t.stripProtocol && (e = e.replace(/^(?:https?:)?\/\//, '')), + e + ); + }; + (e.exports = o), (e.exports.default = o); + }, + 91162: (e, t, r) => { + var A = r(98984); + function n(e) { + var t = function () { + return t.called + ? t.value + : ((t.called = !0), (t.value = e.apply(this, arguments))); + }; + return (t.called = !1), t; + } + (e.exports = A(n)), + (n.proto = n(function () { + Object.defineProperty(Function.prototype, 'once', { + value: function () { + return n(this); + }, + configurable: !0, + }); + })); + }, + 27180: (e, t, r) => { + var A = r(98984); + function n(e) { + var t = function () { + return t.called + ? t.value + : ((t.called = !0), (t.value = e.apply(this, arguments))); + }; + return (t.called = !1), t; + } + function o(e) { + var t = function () { + if (t.called) throw new Error(t.onceError); + return (t.called = !0), (t.value = e.apply(this, arguments)); + }, + r = e.name || 'Function wrapped with `once`'; + return ( + (t.onceError = r + " shouldn't be called more than once"), + (t.called = !1), + t + ); + } + (e.exports = A(n)), + (e.exports.strict = A(o)), + (n.proto = n(function () { + Object.defineProperty(Function.prototype, 'once', { + value: function () { + return n(this); + }, + configurable: !0, + }), + Object.defineProperty(Function.prototype, 'onceStrict', { + value: function () { + return o(this); + }, + configurable: !0, + }); + })); + }, + 59351: (e) => { + 'use strict'; + class t extends Error { + constructor(e) { + super(e || 'Promise was canceled'), (this.name = 'CancelError'); + } + get isCanceled() { + return !0; + } + } + class r { + static fn(e) { + return (...t) => + new r((r, A, n) => { + t.push(n), e(...t).then(r, A); + }); + } + constructor(e) { + (this._cancelHandlers = []), + (this._isPending = !0), + (this._isCanceled = !1), + (this._rejectOnCancel = !0), + (this._promise = new Promise((t, r) => { + this._reject = r; + const A = (e) => { + if (!this._isPending) + throw new Error( + 'The `onCancel` handler was attached after the promise settled.' + ); + this._cancelHandlers.push(e); + }; + return ( + Object.defineProperties(A, { + shouldReject: { + get: () => this._rejectOnCancel, + set: (e) => { + this._rejectOnCancel = e; + }, + }, + }), + e( + (e) => { + (this._isPending = !1), t(e); + }, + (e) => { + (this._isPending = !1), r(e); + }, + A + ) + ); + })); + } + then(e, t) { + return this._promise.then(e, t); + } + catch(e) { + return this._promise.catch(e); + } + finally(e) { + return this._promise.finally(e); + } + cancel(e) { + if (this._isPending && !this._isCanceled) { + if (this._cancelHandlers.length > 0) + try { + for (const e of this._cancelHandlers) e(); + } catch (e) { + this._reject(e); + } + (this._isCanceled = !0), + this._rejectOnCancel && this._reject(new t(e)); + } + } + get isCanceled() { + return this._isCanceled; + } + } + Object.setPrototypeOf(r.prototype, Promise.prototype), + (e.exports = r), + (e.exports.CancelError = t); + }, + 61578: (e, t, r) => { + 'use strict'; + const A = r(60550), + n = (e) => { + if (e < 1) + throw new TypeError( + 'Expected `concurrency` to be a number from 1 and up' + ); + const t = []; + let r = 0; + const n = () => { + r--, t.length > 0 && t.shift()(); + }, + o = (e, t, ...o) => { + r++; + const i = A(e, ...o); + t(i), i.then(n, n); + }, + i = (A, ...n) => + new Promise((i) => + ((A, n, ...i) => { + r < e ? o(A, n, ...i) : t.push(o.bind(null, A, n, ...i)); + })(A, i, ...n) + ); + return ( + Object.defineProperties(i, { + activeCount: { get: () => r }, + pendingCount: { get: () => t.length }, + }), + i + ); + }; + (e.exports = n), (e.exports.default = n); + }, + 60550: (e) => { + 'use strict'; + e.exports = (e, ...t) => + new Promise((r) => { + r(e(...t)); + }); + }, + 37127: (e) => { + 'use strict'; + const t = (e = {}) => { + const t = e.env || process.env; + return 'win32' !== (e.platform || process.platform) + ? 'PATH' + : Object.keys(t) + .reverse() + .find((e) => 'PATH' === e.toUpperCase()) || 'Path'; + }; + (e.exports = t), (e.exports.default = t); + }, + 5763: (e, t, r) => { + 'use strict'; + const { promisify: A } = r(31669), + n = r(35747); + async function o(e, t, r) { + if ('string' != typeof r) + throw new TypeError('Expected a string, got ' + typeof r); + try { + return (await A(n[e])(r))[t](); + } catch (e) { + if ('ENOENT' === e.code) return !1; + throw e; + } + } + function i(e, t, r) { + if ('string' != typeof r) + throw new TypeError('Expected a string, got ' + typeof r); + try { + return n[e](r)[t](); + } catch (e) { + if ('ENOENT' === e.code) return !1; + throw e; + } + } + (t.isFile = o.bind(null, 'stat', 'isFile')), + (t.isDirectory = o.bind(null, 'stat', 'isDirectory')), + (t.isSymlink = o.bind(null, 'lstat', 'isSymbolicLink')), + (t.isFileSync = i.bind(null, 'statSync', 'isFile')), + (t.isDirectorySync = i.bind(null, 'statSync', 'isDirectory')), + (t.isSymlinkSync = i.bind(null, 'lstatSync', 'isSymbolicLink')); + }, + 54722: (e, t, r) => { + 'use strict'; + e.exports = r(18828); + }, + 71086: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = { + DOT_LITERAL: '\\.', + PLUS_LITERAL: '\\+', + QMARK_LITERAL: '\\?', + SLASH_LITERAL: '\\/', + ONE_CHAR: '(?=.)', + QMARK: '[^/]', + END_ANCHOR: '(?:\\/|$)', + DOTS_SLASH: '\\.{1,2}(?:\\/|$)', + NO_DOT: '(?!\\.)', + NO_DOTS: '(?!(?:^|\\/)\\.{1,2}(?:\\/|$))', + NO_DOT_SLASH: '(?!\\.{0,1}(?:\\/|$))', + NO_DOTS_SLASH: '(?!\\.{1,2}(?:\\/|$))', + QMARK_NO_DOT: '[^.\\/]', + STAR: '[^/]*?', + START_ANCHOR: '(?:^|\\/)', + }, + o = { + ...n, + SLASH_LITERAL: '[\\\\/]', + QMARK: '[^\\\\/]', + STAR: '[^\\\\/]*?', + DOTS_SLASH: '\\.{1,2}(?:[\\\\/]|$)', + NO_DOT: '(?!\\.)', + NO_DOTS: '(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))', + NO_DOT_SLASH: '(?!\\.{0,1}(?:[\\\\/]|$))', + NO_DOTS_SLASH: '(?!\\.{1,2}(?:[\\\\/]|$))', + QMARK_NO_DOT: '[^.\\\\/]', + START_ANCHOR: '(?:^|[\\\\/])', + END_ANCHOR: '(?:[\\\\/]|$)', + }; + e.exports = { + MAX_LENGTH: 65536, + 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', + }, + 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, + REPLACEMENTS: { '***': '*', '**/**': '**', '**/**/**': '**' }, + CHAR_0: 48, + CHAR_9: 57, + CHAR_UPPERCASE_A: 65, + CHAR_LOWERCASE_A: 97, + CHAR_UPPERCASE_Z: 90, + CHAR_LOWERCASE_Z: 122, + CHAR_LEFT_PARENTHESES: 40, + CHAR_RIGHT_PARENTHESES: 41, + CHAR_ASTERISK: 42, + CHAR_AMPERSAND: 38, + CHAR_AT: 64, + CHAR_BACKWARD_SLASH: 92, + CHAR_CARRIAGE_RETURN: 13, + 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, + 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, + CHAR_NO_BREAK_SPACE: 160, + 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, + CHAR_UNDERSCORE: 95, + CHAR_VERTICAL_LINE: 124, + CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, + SEP: A.sep, + extglobChars: (e) => ({ + '!': { type: 'negate', open: '(?:(?!(?:', close: `))${e.STAR})` }, + '?': { type: 'qmark', open: '(?:', close: ')?' }, + '+': { type: 'plus', open: '(?:', close: ')+' }, + '*': { type: 'star', open: '(?:', close: ')*' }, + '@': { type: 'at', open: '(?:', close: ')' }, + }), + globChars: (e) => (!0 === e ? o : n), + }; + }, + 47974: (e, t, r) => { + 'use strict'; + const A = r(71086), + n = r(3598), + { + MAX_LENGTH: o, + POSIX_REGEX_SOURCE: i, + REGEX_NON_SPECIAL_CHARS: s, + REGEX_SPECIAL_CHARS_BACKREF: a, + REPLACEMENTS: c, + } = A, + g = (e, t) => { + if ('function' == typeof t.expandRange) + return t.expandRange(...e, t); + e.sort(); + const r = `[${e.join('-')}]`; + try { + new RegExp(r); + } catch (t) { + return e.map((e) => n.escapeRegex(e)).join('..'); + } + return r; + }, + l = (e, t) => + `Missing ${e}: "${t}" - use "\\\\${t}" to match literal characters`, + u = (e, t) => { + if ('string' != typeof e) throw new TypeError('Expected a string'); + e = c[e] || e; + const r = { ...t }, + u = 'number' == typeof r.maxLength ? Math.min(o, r.maxLength) : o; + let h = e.length; + if (h > u) + throw new SyntaxError( + `Input length: ${h}, exceeds maximum allowed length: ${u}` + ); + const p = { type: 'bos', value: '', output: r.prepend || '' }, + d = [p], + C = r.capture ? '' : '?:', + f = n.isWindows(t), + I = A.globChars(f), + E = A.extglobChars(I), + { + DOT_LITERAL: B, + PLUS_LITERAL: y, + SLASH_LITERAL: m, + ONE_CHAR: w, + DOTS_SLASH: Q, + NO_DOT: D, + NO_DOT_SLASH: b, + NO_DOTS_SLASH: v, + QMARK: S, + QMARK_NO_DOT: k, + STAR: N, + START_ANCHOR: F, + } = I, + K = (e) => `(${C}(?:(?!${F}${e.dot ? Q : B}).)*?)`, + M = r.dot ? '' : D, + R = r.dot ? S : k; + let x = !0 === r.bash ? K(r) : N; + r.capture && (x = `(${x})`), + 'boolean' == typeof r.noext && (r.noextglob = r.noext); + const L = { + input: e, + index: -1, + start: 0, + dot: !0 === r.dot, + consumed: '', + output: '', + prefix: '', + backtrack: !1, + negated: !1, + brackets: 0, + braces: 0, + parens: 0, + quotes: 0, + globstar: !1, + tokens: d, + }; + (e = n.removePrefix(e, L)), (h = e.length); + const P = [], + O = [], + U = []; + let T, + j = p; + const Y = () => L.index === h - 1, + G = (L.peek = (t = 1) => e[L.index + t]), + H = (L.advance = () => e[++L.index]), + J = () => e.slice(L.index + 1), + q = (e = '', t = 0) => { + (L.consumed += e), (L.index += t); + }, + z = (e) => { + (L.output += null != e.output ? e.output : e.value), q(e.value); + }, + W = () => { + let e = 1; + for (; '!' === G() && ('(' !== G(2) || '?' === G(3)); ) + H(), L.start++, e++; + return e % 2 != 0 && ((L.negated = !0), L.start++, !0); + }, + V = (e) => { + L[e]++, U.push(e); + }, + X = (e) => { + L[e]--, U.pop(); + }, + _ = (e) => { + if ('globstar' === j.type) { + const t = + L.braces > 0 && + ('comma' === e.type || 'brace' === e.type), + r = + !0 === e.extglob || + (P.length && ('pipe' === e.type || 'paren' === e.type)); + 'slash' === e.type || + 'paren' === e.type || + t || + r || + ((L.output = L.output.slice(0, -j.output.length)), + (j.type = 'star'), + (j.value = '*'), + (j.output = x), + (L.output += j.output)); + } + if ( + (P.length && + 'paren' !== e.type && + !E[e.value] && + (P[P.length - 1].inner += e.value), + (e.value || e.output) && z(e), + j && 'text' === j.type && 'text' === e.type) + ) + return ( + (j.value += e.value), + void (j.output = (j.output || '') + e.value) + ); + (e.prev = j), d.push(e), (j = e); + }, + Z = (e, t) => { + const A = { ...E[t], conditions: 1, inner: '' }; + (A.prev = j), (A.parens = L.parens), (A.output = L.output); + const n = (r.capture ? '(' : '') + A.open; + V('parens'), + _({ type: e, value: t, output: L.output ? '' : w }), + _({ type: 'paren', extglob: !0, value: H(), output: n }), + P.push(A); + }, + $ = (e) => { + let t = e.close + (r.capture ? ')' : ''); + if ('negate' === e.type) { + let A = x; + e.inner && + e.inner.length > 1 && + e.inner.includes('/') && + (A = K(r)), + (A !== x || Y() || /^\)+$/.test(J())) && + (t = e.close = ')$))' + A), + 'bos' === e.prev.type && Y() && (L.negatedExtglob = !0); + } + _({ type: 'paren', extglob: !0, value: T, output: t }), + X('parens'); + }; + if (!1 !== r.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(e)) { + let A = !1, + o = e.replace(a, (e, t, r, n, o, i) => + '\\' === n + ? ((A = !0), e) + : '?' === n + ? t + ? t + n + (o ? S.repeat(o.length) : '') + : 0 === i + ? R + (o ? S.repeat(o.length) : '') + : S.repeat(r.length) + : '.' === n + ? B.repeat(r.length) + : '*' === n + ? t + ? t + n + (o ? x : '') + : x + : t + ? e + : '\\' + e + ); + return ( + !0 === A && + (o = + !0 === r.unescape + ? o.replace(/\\/g, '') + : o.replace(/\\+/g, (e) => + e.length % 2 == 0 ? '\\\\' : e ? '\\' : '' + )), + o === e && !0 === r.contains + ? ((L.output = e), L) + : ((L.output = n.wrapOutput(o, L, t)), L) + ); + } + for (; !Y(); ) { + if (((T = H()), '\0' === T)) continue; + if ('\\' === T) { + const e = G(); + if ('/' === e && !0 !== r.bash) continue; + if ('.' === e || ';' === e) continue; + if (!e) { + (T += '\\'), _({ type: 'text', value: T }); + continue; + } + const t = /^\\+/.exec(J()); + let A = 0; + if ( + (t && + t[0].length > 2 && + ((A = t[0].length), + (L.index += A), + A % 2 != 0 && (T += '\\')), + !0 === r.unescape ? (T = H() || '') : (T += H() || ''), + 0 === L.brackets) + ) { + _({ type: 'text', value: T }); + continue; + } + } + if ( + L.brackets > 0 && + (']' !== T || '[' === j.value || '[^' === j.value) + ) { + if (!1 !== r.posix && ':' === T) { + const e = j.value.slice(1); + if (e.includes('[') && ((j.posix = !0), e.includes(':'))) { + const e = j.value.lastIndexOf('['), + t = j.value.slice(0, e), + r = j.value.slice(e + 2), + A = i[r]; + if (A) { + (j.value = t + A), + (L.backtrack = !0), + H(), + p.output || 1 !== d.indexOf(j) || (p.output = w); + continue; + } + } + } + (('[' === T && ':' !== G()) || ('-' === T && ']' === G())) && + (T = '\\' + T), + ']' !== T || + ('[' !== j.value && '[^' !== j.value) || + (T = '\\' + T), + !0 === r.posix && '!' === T && '[' === j.value && (T = '^'), + (j.value += T), + z({ value: T }); + continue; + } + if (1 === L.quotes && '"' !== T) { + (T = n.escapeRegex(T)), (j.value += T), z({ value: T }); + continue; + } + if ('"' === T) { + (L.quotes = 1 === L.quotes ? 0 : 1), + !0 === r.keepQuotes && _({ type: 'text', value: T }); + continue; + } + if ('(' === T) { + V('parens'), _({ type: 'paren', value: T }); + continue; + } + if (')' === T) { + if (0 === L.parens && !0 === r.strictBrackets) + throw new SyntaxError(l('opening', '(')); + const e = P[P.length - 1]; + if (e && L.parens === e.parens + 1) { + $(P.pop()); + continue; + } + _({ type: 'paren', value: T, output: L.parens ? ')' : '\\)' }), + X('parens'); + continue; + } + if ('[' === T) { + if (!0 !== r.nobracket && J().includes(']')) V('brackets'); + else { + if (!0 !== r.nobracket && !0 === r.strictBrackets) + throw new SyntaxError(l('closing', ']')); + T = '\\' + T; + } + _({ type: 'bracket', value: T }); + continue; + } + if (']' === T) { + if ( + !0 === r.nobracket || + (j && 'bracket' === j.type && 1 === j.value.length) + ) { + _({ type: 'text', value: T, output: '\\' + T }); + continue; + } + if (0 === L.brackets) { + if (!0 === r.strictBrackets) + throw new SyntaxError(l('opening', '[')); + _({ type: 'text', value: T, output: '\\' + T }); + continue; + } + X('brackets'); + const e = j.value.slice(1); + if ( + (!0 === j.posix || + '^' !== e[0] || + e.includes('/') || + (T = '/' + T), + (j.value += T), + z({ value: T }), + !1 === r.literalBrackets || n.hasRegexChars(e)) + ) + continue; + const t = n.escapeRegex(j.value); + if ( + ((L.output = L.output.slice(0, -j.value.length)), + !0 === r.literalBrackets) + ) { + (L.output += t), (j.value = t); + continue; + } + (j.value = `(${C}${t}|${j.value})`), (L.output += j.value); + continue; + } + if ('{' === T && !0 !== r.nobrace) { + V('braces'); + const e = { + type: 'brace', + value: T, + output: '(', + outputIndex: L.output.length, + tokensIndex: L.tokens.length, + }; + O.push(e), _(e); + continue; + } + if ('}' === T) { + const e = O[O.length - 1]; + if (!0 === r.nobrace || !e) { + _({ type: 'text', value: T, output: T }); + continue; + } + let t = ')'; + if (!0 === e.dots) { + const e = d.slice(), + A = []; + for ( + let t = e.length - 1; + t >= 0 && (d.pop(), 'brace' !== e[t].type); + t-- + ) + 'dots' !== e[t].type && A.unshift(e[t].value); + (t = g(A, r)), (L.backtrack = !0); + } + if (!0 !== e.comma && !0 !== e.dots) { + const r = L.output.slice(0, e.outputIndex), + A = L.tokens.slice(e.tokensIndex); + (e.value = e.output = '\\{'), (T = t = '\\}'), (L.output = r); + for (const e of A) L.output += e.output || e.value; + } + _({ type: 'brace', value: T, output: t }), X('braces'), O.pop(); + continue; + } + if ('|' === T) { + P.length > 0 && P[P.length - 1].conditions++, + _({ type: 'text', value: T }); + continue; + } + if (',' === T) { + let e = T; + const t = O[O.length - 1]; + t && + 'braces' === U[U.length - 1] && + ((t.comma = !0), (e = '|')), + _({ type: 'comma', value: T, output: e }); + continue; + } + if ('/' === T) { + if ('dot' === j.type && L.index === L.start + 1) { + (L.start = L.index + 1), + (L.consumed = ''), + (L.output = ''), + d.pop(), + (j = p); + continue; + } + _({ type: 'slash', value: T, output: m }); + continue; + } + if ('.' === T) { + if (L.braces > 0 && 'dot' === j.type) { + '.' === j.value && (j.output = B); + const e = O[O.length - 1]; + (j.type = 'dots'), + (j.output += T), + (j.value += T), + (e.dots = !0); + continue; + } + if ( + L.braces + L.parens === 0 && + 'bos' !== j.type && + 'slash' !== j.type + ) { + _({ type: 'text', value: T, output: B }); + continue; + } + _({ type: 'dot', value: T, output: B }); + continue; + } + if ('?' === T) { + if ( + !(j && '(' === j.value) && + !0 !== r.noextglob && + '(' === G() && + '?' !== G(2) + ) { + Z('qmark', T); + continue; + } + if (j && 'paren' === j.type) { + const e = G(); + let t = T; + if ('<' === e && !n.supportsLookbehinds()) + throw new Error( + 'Node.js v10 or higher is required for regex lookbehinds' + ); + (('(' === j.value && !/[!=<:]/.test(e)) || + ('<' === e && !/<([!=]|\w+>)/.test(J()))) && + (t = '\\' + T), + _({ type: 'text', value: T, output: t }); + continue; + } + if (!0 !== r.dot && ('slash' === j.type || 'bos' === j.type)) { + _({ type: 'qmark', value: T, output: k }); + continue; + } + _({ type: 'qmark', value: T, output: S }); + continue; + } + if ('!' === T) { + if ( + !0 !== r.noextglob && + '(' === G() && + ('?' !== G(2) || !/[!=<:]/.test(G(3))) + ) { + Z('negate', T); + continue; + } + if (!0 !== r.nonegate && 0 === L.index) { + W(); + continue; + } + } + if ('+' === T) { + if (!0 !== r.noextglob && '(' === G() && '?' !== G(2)) { + Z('plus', T); + continue; + } + if ((j && '(' === j.value) || !1 === r.regex) { + _({ type: 'plus', value: T, output: y }); + continue; + } + if ( + (j && + ('bracket' === j.type || + 'paren' === j.type || + 'brace' === j.type)) || + L.parens > 0 + ) { + _({ type: 'plus', value: T }); + continue; + } + _({ type: 'plus', value: y }); + continue; + } + if ('@' === T) { + if (!0 !== r.noextglob && '(' === G() && '?' !== G(2)) { + _({ type: 'at', extglob: !0, value: T, output: '' }); + continue; + } + _({ type: 'text', value: T }); + continue; + } + if ('*' !== T) { + ('$' !== T && '^' !== T) || (T = '\\' + T); + const e = s.exec(J()); + e && ((T += e[0]), (L.index += e[0].length)), + _({ type: 'text', value: T }); + continue; + } + if (j && ('globstar' === j.type || !0 === j.star)) { + (j.type = 'star'), + (j.star = !0), + (j.value += T), + (j.output = x), + (L.backtrack = !0), + (L.globstar = !0), + q(T); + continue; + } + let t = J(); + if (!0 !== r.noextglob && /^\([^?]/.test(t)) { + Z('star', T); + continue; + } + if ('star' === j.type) { + if (!0 === r.noglobstar) { + q(T); + continue; + } + const A = j.prev, + n = A.prev, + o = 'slash' === A.type || 'bos' === A.type, + i = n && ('star' === n.type || 'globstar' === n.type); + if (!0 === r.bash && (!o || (t[0] && '/' !== t[0]))) { + _({ type: 'star', value: T, output: '' }); + continue; + } + const s = + L.braces > 0 && ('comma' === A.type || 'brace' === A.type), + a = P.length && ('pipe' === A.type || 'paren' === A.type); + if (!o && 'paren' !== A.type && !s && !a) { + _({ type: 'star', value: T, output: '' }); + continue; + } + for (; '/**' === t.slice(0, 3); ) { + const r = e[L.index + 4]; + if (r && '/' !== r) break; + (t = t.slice(3)), q('/**', 3); + } + if ('bos' === A.type && Y()) { + (j.type = 'globstar'), + (j.value += T), + (j.output = K(r)), + (L.output = j.output), + (L.globstar = !0), + q(T); + continue; + } + if ('slash' === A.type && 'bos' !== A.prev.type && !i && Y()) { + (L.output = L.output.slice(0, -(A.output + j.output).length)), + (A.output = '(?:' + A.output), + (j.type = 'globstar'), + (j.output = K(r) + (r.strictSlashes ? ')' : '|$)')), + (j.value += T), + (L.globstar = !0), + (L.output += A.output + j.output), + q(T); + continue; + } + if ( + 'slash' === A.type && + 'bos' !== A.prev.type && + '/' === t[0] + ) { + const e = void 0 !== t[1] ? '|$' : ''; + (L.output = L.output.slice(0, -(A.output + j.output).length)), + (A.output = '(?:' + A.output), + (j.type = 'globstar'), + (j.output = `${K(r)}${m}|${m}${e})`), + (j.value += T), + (L.output += A.output + j.output), + (L.globstar = !0), + q(T + H()), + _({ type: 'slash', value: '/', output: '' }); + continue; + } + if ('bos' === A.type && '/' === t[0]) { + (j.type = 'globstar'), + (j.value += T), + (j.output = `(?:^|${m}|${K(r)}${m})`), + (L.output = j.output), + (L.globstar = !0), + q(T + H()), + _({ type: 'slash', value: '/', output: '' }); + continue; + } + (L.output = L.output.slice(0, -j.output.length)), + (j.type = 'globstar'), + (j.output = K(r)), + (j.value += T), + (L.output += j.output), + (L.globstar = !0), + q(T); + continue; + } + const A = { type: 'star', value: T, output: x }; + !0 !== r.bash + ? !j || + ('bracket' !== j.type && 'paren' !== j.type) || + !0 !== r.regex + ? ((L.index !== L.start && + 'slash' !== j.type && + 'dot' !== j.type) || + ('dot' === j.type + ? ((L.output += b), (j.output += b)) + : !0 === r.dot + ? ((L.output += v), (j.output += v)) + : ((L.output += M), (j.output += M)), + '*' !== G() && ((L.output += w), (j.output += w))), + _(A)) + : ((A.output = T), _(A)) + : ((A.output = '.*?'), + ('bos' !== j.type && 'slash' !== j.type) || + (A.output = M + A.output), + _(A)); + } + for (; L.brackets > 0; ) { + if (!0 === r.strictBrackets) + throw new SyntaxError(l('closing', ']')); + (L.output = n.escapeLast(L.output, '[')), X('brackets'); + } + for (; L.parens > 0; ) { + if (!0 === r.strictBrackets) + throw new SyntaxError(l('closing', ')')); + (L.output = n.escapeLast(L.output, '(')), X('parens'); + } + for (; L.braces > 0; ) { + if (!0 === r.strictBrackets) + throw new SyntaxError(l('closing', '}')); + (L.output = n.escapeLast(L.output, '{')), X('braces'); + } + if ( + (!0 === r.strictSlashes || + ('star' !== j.type && 'bracket' !== j.type) || + _({ type: 'maybe_slash', value: '', output: m + '?' }), + !0 === L.backtrack) + ) { + L.output = ''; + for (const e of L.tokens) + (L.output += null != e.output ? e.output : e.value), + e.suffix && (L.output += e.suffix); + } + return L; + }; + (u.fastpaths = (e, t) => { + const r = { ...t }, + i = 'number' == typeof r.maxLength ? Math.min(o, r.maxLength) : o, + s = e.length; + if (s > i) + throw new SyntaxError( + `Input length: ${s}, exceeds maximum allowed length: ${i}` + ); + e = c[e] || e; + const a = n.isWindows(t), + { + DOT_LITERAL: g, + SLASH_LITERAL: l, + ONE_CHAR: u, + DOTS_SLASH: h, + NO_DOT: p, + NO_DOTS: d, + NO_DOTS_SLASH: C, + STAR: f, + START_ANCHOR: I, + } = A.globChars(a), + E = r.dot ? d : p, + B = r.dot ? C : p, + y = r.capture ? '' : '?:'; + let m = !0 === r.bash ? '.*?' : f; + r.capture && (m = `(${m})`); + const w = (e) => + !0 === e.noglobstar ? m : `(${y}(?:(?!${I}${e.dot ? h : g}).)*?)`, + Q = (e) => { + switch (e) { + case '*': + return `${E}${u}${m}`; + case '.*': + return `${g}${u}${m}`; + case '*.*': + return `${E}${m}${g}${u}${m}`; + case '*/*': + return `${E}${m}${l}${u}${B}${m}`; + case '**': + return E + w(r); + case '**/*': + return `(?:${E}${w(r)}${l})?${B}${u}${m}`; + case '**/*.*': + return `(?:${E}${w(r)}${l})?${B}${m}${g}${u}${m}`; + case '**/.*': + return `(?:${E}${w(r)}${l})?${g}${u}${m}`; + default: { + const t = /^(.*?)\.(\w+)$/.exec(e); + if (!t) return; + const r = Q(t[1]); + if (!r) return; + return r + g + t[2]; + } + } + }, + D = n.removePrefix(e, { negated: !1, prefix: '' }); + let b = Q(D); + return b && !0 !== r.strictSlashes && (b += l + '?'), b; + }), + (e.exports = u); + }, + 18828: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = r(95321), + o = r(47974), + i = r(3598), + s = r(71086), + a = (e, t, r = !1) => { + if (Array.isArray(e)) { + const A = e.map((e) => a(e, t, r)); + return (e) => { + for (const t of A) { + const r = t(e); + if (r) return r; + } + return !1; + }; + } + const A = + (n = e) && + 'object' == typeof n && + !Array.isArray(n) && + e.tokens && + e.input; + var n; + if ('' === e || ('string' != typeof e && !A)) + throw new TypeError('Expected pattern to be a non-empty string'); + const o = t || {}, + s = i.isWindows(t), + c = A ? a.compileRe(e, t) : a.makeRe(e, t, !1, !0), + g = c.state; + delete c.state; + let l = () => !1; + if (o.ignore) { + const e = { ...t, ignore: null, onMatch: null, onResult: null }; + l = a(o.ignore, e, r); + } + const u = (r, A = !1) => { + const { isMatch: n, match: i, output: u } = a.test(r, c, t, { + glob: e, + posix: s, + }), + h = { + glob: e, + state: g, + regex: c, + posix: s, + input: r, + output: u, + match: i, + isMatch: n, + }; + return ( + 'function' == typeof o.onResult && o.onResult(h), + !1 === n + ? ((h.isMatch = !1), !!A && h) + : l(r) + ? ('function' == typeof o.onIgnore && o.onIgnore(h), + (h.isMatch = !1), + !!A && h) + : ('function' == typeof o.onMatch && o.onMatch(h), !A || h) + ); + }; + return r && (u.state = g), u; + }; + (a.test = (e, t, r, { glob: A, posix: n } = {}) => { + if ('string' != typeof e) + throw new TypeError('Expected input to be a string'); + if ('' === e) return { isMatch: !1, output: '' }; + const o = r || {}, + s = o.format || (n ? i.toPosixSlashes : null); + let c = e === A, + g = c && s ? s(e) : e; + return ( + !1 === c && ((g = s ? s(e) : e), (c = g === A)), + (!1 !== c && !0 !== o.capture) || + (c = + !0 === o.matchBase || !0 === o.basename + ? a.matchBase(e, t, r, n) + : t.exec(g)), + { isMatch: Boolean(c), match: c, output: g } + ); + }), + (a.matchBase = (e, t, r, n = i.isWindows(r)) => + (t instanceof RegExp ? t : a.makeRe(t, r)).test(A.basename(e))), + (a.isMatch = (e, t, r) => a(t, r)(e)), + (a.parse = (e, t) => + Array.isArray(e) + ? e.map((e) => a.parse(e, t)) + : o(e, { ...t, fastpaths: !1 })), + (a.scan = (e, t) => n(e, t)), + (a.compileRe = (e, t, r = !1, A = !1) => { + if (!0 === r) return e.output; + const n = t || {}, + o = n.contains ? '' : '^', + i = n.contains ? '' : '$'; + let s = `${o}(?:${e.output})${i}`; + e && !0 === e.negated && (s = `^(?!${s}).*$`); + const c = a.toRegex(s, t); + return !0 === A && (c.state = e), c; + }), + (a.makeRe = (e, t, r = !1, A = !1) => { + if (!e || 'string' != typeof e) + throw new TypeError('Expected a non-empty string'); + const n = t || {}; + let i, + s = { negated: !1, fastpaths: !0 }, + c = ''; + return ( + e.startsWith('./') && ((e = e.slice(2)), (c = s.prefix = './')), + !1 === n.fastpaths || + ('.' !== e[0] && '*' !== e[0]) || + (i = o.fastpaths(e, t)), + void 0 === i + ? ((s = o(e, t)), (s.prefix = c + (s.prefix || ''))) + : (s.output = i), + a.compileRe(s, t, r, A) + ); + }), + (a.toRegex = (e, t) => { + try { + const r = t || {}; + return new RegExp(e, r.flags || (r.nocase ? 'i' : '')); + } catch (e) { + if (t && !0 === t.debug) throw e; + return /$^/; + } + }), + (a.constants = s), + (e.exports = a); + }, + 95321: (e, t, r) => { + 'use strict'; + const A = r(3598), + { + CHAR_ASTERISK: n, + CHAR_AT: o, + CHAR_BACKWARD_SLASH: i, + CHAR_COMMA: s, + CHAR_DOT: a, + CHAR_EXCLAMATION_MARK: c, + CHAR_FORWARD_SLASH: g, + CHAR_LEFT_CURLY_BRACE: l, + CHAR_LEFT_PARENTHESES: u, + CHAR_LEFT_SQUARE_BRACKET: h, + CHAR_PLUS: p, + CHAR_QUESTION_MARK: d, + CHAR_RIGHT_CURLY_BRACE: C, + CHAR_RIGHT_PARENTHESES: f, + CHAR_RIGHT_SQUARE_BRACKET: I, + } = r(71086), + E = (e) => e === g || e === i, + B = (e) => { + !0 !== e.isPrefix && (e.depth = e.isGlobstar ? 1 / 0 : 1); + }; + e.exports = (e, t) => { + const r = t || {}, + y = e.length - 1, + m = !0 === r.parts || !0 === r.scanToEnd, + w = [], + Q = [], + D = []; + let b, + v, + S = e, + k = -1, + N = 0, + F = 0, + K = !1, + M = !1, + R = !1, + x = !1, + L = !1, + P = !1, + O = !1, + U = !1, + T = !1, + j = 0, + Y = { value: '', depth: 0, isGlob: !1 }; + const G = () => k >= y, + H = () => ((b = v), S.charCodeAt(++k)); + for (; k < y; ) { + let e; + if (((v = H()), v !== i)) { + if (!0 === P || v === l) { + for (j++; !0 !== G() && (v = H()); ) + if (v !== i) + if (v !== l) { + if (!0 !== P && v === a && (v = H()) === a) { + if ( + ((K = Y.isBrace = !0), + (R = Y.isGlob = !0), + (T = !0), + !0 === m) + ) + continue; + break; + } + if (!0 !== P && v === s) { + if ( + ((K = Y.isBrace = !0), + (R = Y.isGlob = !0), + (T = !0), + !0 === m) + ) + continue; + break; + } + if (v === C && (j--, 0 === j)) { + (P = !1), (K = Y.isBrace = !0), (T = !0); + break; + } + } else j++; + else (O = Y.backslashes = !0), H(); + if (!0 === m) continue; + break; + } + if (v !== g) { + if (!0 !== r.noext) { + if ( + !0 === + (v === p || v === o || v === n || v === d || v === c) && + S.charCodeAt(k + 1) === u + ) { + if ( + ((R = Y.isGlob = !0), + (x = Y.isExtglob = !0), + (T = !0), + !0 === m) + ) { + for (; !0 !== G() && (v = H()); ) + if (v !== i) { + if (v === f) { + (R = Y.isGlob = !0), (T = !0); + break; + } + } else (O = Y.backslashes = !0), (v = H()); + continue; + } + break; + } + } + if (v === n) { + if ( + (b === n && (L = Y.isGlobstar = !0), + (R = Y.isGlob = !0), + (T = !0), + !0 === m) + ) + continue; + break; + } + if (v === d) { + if (((R = Y.isGlob = !0), (T = !0), !0 === m)) continue; + break; + } + if (v === h) + for (; !0 !== G() && (e = H()); ) + if (e !== i) { + if (e === I) { + if ( + ((M = Y.isBracket = !0), + (R = Y.isGlob = !0), + (T = !0), + !0 === m) + ) + continue; + break; + } + } else (O = Y.backslashes = !0), H(); + if (!0 === r.nonegate || v !== c || k !== N) { + if (!0 !== r.noparen && v === u) { + if (((R = Y.isGlob = !0), !0 === m)) { + for (; !0 !== G() && (v = H()); ) + if (v !== u) { + if (v === f) { + T = !0; + break; + } + } else (O = Y.backslashes = !0), (v = H()); + continue; + } + break; + } + if (!0 === R) { + if (((T = !0), !0 === m)) continue; + break; + } + } else (U = Y.negated = !0), N++; + } else { + if ( + (w.push(k), + Q.push(Y), + (Y = { value: '', depth: 0, isGlob: !1 }), + !0 === T) + ) + continue; + if (b === a && k === N + 1) { + N += 2; + continue; + } + F = k + 1; + } + } else (O = Y.backslashes = !0), (v = H()), v === l && (P = !0); + } + !0 === r.noext && ((x = !1), (R = !1)); + let J = S, + q = '', + z = ''; + N > 0 && ((q = S.slice(0, N)), (S = S.slice(N)), (F -= N)), + J && !0 === R && F > 0 + ? ((J = S.slice(0, F)), (z = S.slice(F))) + : !0 === R + ? ((J = ''), (z = S)) + : (J = S), + J && + '' !== J && + '/' !== J && + J !== S && + E(J.charCodeAt(J.length - 1)) && + (J = J.slice(0, -1)), + !0 === r.unescape && + (z && (z = A.removeBackslashes(z)), + J && !0 === O && (J = A.removeBackslashes(J))); + const W = { + prefix: q, + input: e, + start: N, + base: J, + glob: z, + isBrace: K, + isBracket: M, + isGlob: R, + isExtglob: x, + isGlobstar: L, + negated: U, + }; + if ( + (!0 === r.tokens && + ((W.maxDepth = 0), E(v) || Q.push(Y), (W.tokens = Q)), + !0 === r.parts || !0 === r.tokens) + ) { + let t; + for (let A = 0; A < w.length; A++) { + const n = t ? t + 1 : N, + o = w[A], + i = e.slice(n, o); + r.tokens && + (0 === A && 0 !== N + ? ((Q[A].isPrefix = !0), (Q[A].value = q)) + : (Q[A].value = i), + B(Q[A]), + (W.maxDepth += Q[A].depth)), + (0 === A && '' === i) || D.push(i), + (t = o); + } + if (t && t + 1 < e.length) { + const A = e.slice(t + 1); + D.push(A), + r.tokens && + ((Q[Q.length - 1].value = A), + B(Q[Q.length - 1]), + (W.maxDepth += Q[Q.length - 1].depth)); + } + (W.slashes = w), (W.parts = D); + } + return W; + }; + }, + 3598: (e, t, r) => { + 'use strict'; + const A = r(85622), + n = 'win32' === process.platform, + { + REGEX_BACKSLASH: o, + REGEX_REMOVE_BACKSLASH: i, + REGEX_SPECIAL_CHARS: s, + REGEX_SPECIAL_CHARS_GLOBAL: a, + } = r(71086); + (t.isObject = (e) => + null !== e && 'object' == typeof e && !Array.isArray(e)), + (t.hasRegexChars = (e) => s.test(e)), + (t.isRegexChar = (e) => 1 === e.length && t.hasRegexChars(e)), + (t.escapeRegex = (e) => e.replace(a, '\\$1')), + (t.toPosixSlashes = (e) => e.replace(o, '/')), + (t.removeBackslashes = (e) => + e.replace(i, (e) => ('\\' === e ? '' : e))), + (t.supportsLookbehinds = () => { + const e = process.version.slice(1).split('.').map(Number); + return (3 === e.length && e[0] >= 9) || (8 === e[0] && e[1] >= 10); + }), + (t.isWindows = (e) => + e && 'boolean' == typeof e.windows + ? e.windows + : !0 === n || '\\' === A.sep), + (t.escapeLast = (e, r, A) => { + const n = e.lastIndexOf(r, A); + return -1 === n + ? e + : '\\' === e[n - 1] + ? t.escapeLast(e, r, n - 1) + : `${e.slice(0, n)}\\${e.slice(n)}`; + }), + (t.removePrefix = (e, t = {}) => { + let r = e; + return ( + r.startsWith('./') && ((r = r.slice(2)), (t.prefix = './')), r + ); + }), + (t.wrapOutput = (e, t = {}, r = {}) => { + let A = `${r.contains ? '' : '^'}(?:${e})${r.contains ? '' : '$'}`; + return !0 === t.negated && (A = `(?:^(?!${A}).*$)`), A; + }); + }, + 79588: (e) => { + 'use strict'; + function t(e) { + (this._maxSize = e), this.clear(); + } + (t.prototype.clear = function () { + (this._size = 0), (this._values = {}); + }), + (t.prototype.get = function (e) { + return this._values[e]; + }), + (t.prototype.set = function (e, t) { + return ( + this._size >= this._maxSize && this.clear(), + this._values.hasOwnProperty(e) || this._size++, + (this._values[e] = t) + ); + }); + var r = /[^.^\]^[]+|(?=\[\]|\.\.)/g, + A = /^\d+$/, + n = /^\d/, + o = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g, + i = /^\s*(['"]?)(.*?)(\1)\s*$/, + s = !1, + a = new t(512), + c = new t(512), + g = new t(512); + try { + new Function(''); + } catch (e) { + s = !0; + } + function l(e) { + return ( + a.get(e) || + a.set( + e, + u(e).map(function (e) { + return e.replace(i, '$2'); + }) + ) + ); + } + function u(e) { + return e.match(r); + } + function h(e, t, r) { + return ( + 'string' == typeof t && ((r = t), (t = !1)), + (r = r || 'data'), + (e = e || '') && '[' !== e.charAt(0) && (e = '.' + e), + t + ? (function (e, t) { + var r, + A = t, + n = u(e); + return ( + p(n, function (e, t, n, o, i) { + (r = o === i.length - 1), + (A += + (e = t || n ? '[' + e + ']' : '.' + e) + + (r ? ')' : ' || {})')); + }), + new Array(n.length + 1).join('(') + A + ); + })(e, r) + : r + e + ); + } + function p(e, t, r) { + var A, + n, + o, + i, + s = e.length; + for (n = 0; n < s; n++) + (A = e[n]) && + (C(A) && (A = '"' + A + '"'), + (o = !(i = d(A)) && /^\d+$/.test(A)), + t.call(r, A, i, o, n, e)); + } + function d(e) { + return ( + 'string' == typeof e && e && -1 !== ["'", '"'].indexOf(e.charAt(0)) + ); + } + function C(e) { + return ( + !d(e) && + ((function (e) { + return e.match(n) && !e.match(A); + })(e) || + (function (e) { + return o.test(e); + })(e)) + ); + } + e.exports = { + Cache: t, + expr: h, + split: u, + normalizePath: l, + setter: s + ? function (e) { + var t = l(e); + return function (e, r) { + return (function (e, t, r) { + var A = 0, + n = e.length; + for (; A < n - 1; ) t = t[e[A++]]; + t[e[A]] = r; + })(t, e, r); + }; + } + : function (e) { + return ( + c.get(e) || + c.set( + e, + new Function('data, value', h(e, 'data') + ' = value') + ) + ); + }, + getter: s + ? function (e, t) { + var r = l(e); + return function (e) { + return (function (e, t, r) { + var A = 0, + n = e.length; + for (; A < n; ) { + if (null == r && t) return; + r = r[e[A++]]; + } + return r; + })(r, t, e); + }; + } + : function (e, t) { + var r = e + '_' + t; + return ( + g.get(r) || + g.set(r, new Function('data', 'return ' + h(e, t, 'data'))) + ); + }, + join: function (e) { + return e.reduce(function (e, t) { + return ( + e + (d(t) || A.test(t) ? '[' + t + ']' : (e ? '.' : '') + t) + ); + }, ''); + }, + forEach: function (e, t, r) { + p(u(e), t, r); + }, + }; + }, + 50372: (e, t, r) => { + var A = r(91162), + n = r(97681), + o = r(35747), + i = function () {}, + s = /^v?\.0/.test(process.version), + a = function (e) { + return 'function' == typeof e; + }, + c = function (e, t, r, c) { + c = A(c); + var g = !1; + e.on('close', function () { + g = !0; + }), + n(e, { readable: t, writable: r }, function (e) { + if (e) return c(e); + (g = !0), c(); + }); + var l = !1; + return function (t) { + if (!g && !l) + return ( + (l = !0), + (function (e) { + return ( + !!s && + !!o && + (e instanceof (o.ReadStream || i) || + e instanceof (o.WriteStream || i)) && + a(e.close) + ); + })(e) + ? e.close(i) + : (function (e) { + return e.setHeader && a(e.abort); + })(e) + ? e.abort() + : a(e.destroy) + ? e.destroy() + : void c(t || new Error('stream was destroyed')) + ); + }; + }, + g = function (e) { + e(); + }, + l = function (e, t) { + return e.pipe(t); + }; + e.exports = function () { + var e, + t = Array.prototype.slice.call(arguments), + r = (a(t[t.length - 1] || i) && t.pop()) || i; + if ((Array.isArray(t[0]) && (t = t[0]), t.length < 2)) + throw new Error('pump requires two streams per minimum'); + var A = t.map(function (n, o) { + var i = o < t.length - 1; + return c(n, i, o > 0, function (t) { + e || (e = t), t && A.forEach(g), i || (A.forEach(g), r(e)); + }); + }); + return t.reduce(l); + }; + }, + 49601: (e) => { + 'use strict'; + class t { + constructor(e = {}) { + if (!(e.maxSize && e.maxSize > 0)) + throw new TypeError('`maxSize` must be a number greater than 0'); + (this.maxSize = e.maxSize), + (this.onEviction = e.onEviction), + (this.cache = new Map()), + (this.oldCache = new Map()), + (this._size = 0); + } + _set(e, t) { + if ( + (this.cache.set(e, t), this._size++, this._size >= this.maxSize) + ) { + if (((this._size = 0), 'function' == typeof this.onEviction)) + for (const [e, t] of this.oldCache.entries()) + this.onEviction(e, t); + (this.oldCache = this.cache), (this.cache = new Map()); + } + } + get(e) { + if (this.cache.has(e)) return this.cache.get(e); + if (this.oldCache.has(e)) { + const t = this.oldCache.get(e); + return this.oldCache.delete(e), this._set(e, t), t; + } + } + set(e, t) { + return ( + this.cache.has(e) ? this.cache.set(e, t) : this._set(e, t), this + ); + } + has(e) { + return this.cache.has(e) || this.oldCache.has(e); + } + peek(e) { + return this.cache.has(e) + ? this.cache.get(e) + : this.oldCache.has(e) + ? this.oldCache.get(e) + : void 0; + } + delete(e) { + const t = this.cache.delete(e); + return t && this._size--, this.oldCache.delete(e) || t; + } + clear() { + this.cache.clear(), this.oldCache.clear(), (this._size = 0); + } + *keys() { + for (const [e] of this) yield e; + } + *values() { + for (const [, e] of this) yield e; + } + *[Symbol.iterator]() { + for (const e of this.cache) yield e; + for (const e of this.oldCache) { + const [t] = e; + this.cache.has(t) || (yield e); + } + } + get size() { + let e = 0; + for (const t of this.oldCache.keys()) this.cache.has(t) || e++; + return Math.min(this._size + e, this.maxSize); + } + } + e.exports = t; + }, + 20663: (e) => { + 'use strict'; + const t = {}; + function r(e, r, A) { + A || (A = Error); + class n extends A { + constructor(e, t, A) { + super( + (function (e, t, A) { + return 'string' == typeof r ? r : r(e, t, A); + })(e, t, A) + ); + } + } + (n.prototype.name = A.name), (n.prototype.code = e), (t[e] = n); + } + function A(e, t) { + if (Array.isArray(e)) { + const r = e.length; + return ( + (e = e.map((e) => String(e))), + r > 2 + ? `one of ${t} ${e.slice(0, r - 1).join(', ')}, or ` + e[r - 1] + : 2 === r + ? `one of ${t} ${e[0]} or ${e[1]}` + : `of ${t} ${e[0]}` + ); + } + return `of ${t} ${String(e)}`; + } + r( + 'ERR_INVALID_OPT_VALUE', + function (e, t) { + return 'The value "' + t + '" is invalid for option "' + e + '"'; + }, + TypeError + ), + r( + 'ERR_INVALID_ARG_TYPE', + function (e, t, r) { + let n; + var o, i; + let s; + if ( + ('string' == typeof t && + ((o = 'not '), t.substr(!i || i < 0 ? 0 : +i, o.length) === o) + ? ((n = 'must not be'), (t = t.replace(/^not /, ''))) + : (n = 'must be'), + (function (e, t, r) { + return ( + (void 0 === r || r > e.length) && (r = e.length), + e.substring(r - t.length, r) === t + ); + })(e, ' argument')) + ) + s = `The ${e} ${n} ${A(t, 'type')}`; + else { + s = `The "${e}" ${ + (function (e, t, r) { + return ( + 'number' != typeof r && (r = 0), + !(r + t.length > e.length) && -1 !== e.indexOf(t, r) + ); + })(e, '.') + ? 'property' + : 'argument' + } ${n} ${A(t, 'type')}`; + } + return (s += '. Received type ' + typeof r), s; + }, + TypeError + ), + r('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'), + r('ERR_METHOD_NOT_IMPLEMENTED', function (e) { + return 'The ' + e + ' method is not implemented'; + }), + r('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'), + r('ERR_STREAM_DESTROYED', function (e) { + return 'Cannot call ' + e + ' after a stream was destroyed'; + }), + r('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'), + r('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'), + r('ERR_STREAM_WRITE_AFTER_END', 'write after end'), + r( + 'ERR_STREAM_NULL_VALUES', + 'May not write null values to stream', + TypeError + ), + r( + 'ERR_UNKNOWN_ENCODING', + function (e) { + return 'Unknown encoding: ' + e; + }, + TypeError + ), + r( + 'ERR_STREAM_UNSHIFT_AFTER_END_EVENT', + 'stream.unshift() after end event' + ), + (e.exports.q = t); + }, + 39138: (e) => { + 'use strict'; + var t = new Set(); + e.exports.emitExperimentalWarning = process.emitWarning + ? function (e) { + if (!t.has(e)) { + var r = + e + + ' is an experimental feature. This feature could change at any time'; + t.add(e), process.emitWarning(r, 'ExperimentalWarning'); + } + } + : function () {}; + }, + 72434: (e, t, r) => { + 'use strict'; + var A = + Object.keys || + function (e) { + var t = []; + for (var r in e) t.push(r); + return t; + }; + e.exports = c; + var n = r(58020), + o = r(6729); + r(85870)(c, n); + for (var i = A(o.prototype), s = 0; s < i.length; s++) { + var a = i[s]; + c.prototype[a] || (c.prototype[a] = o.prototype[a]); + } + function c(e) { + if (!(this instanceof c)) return new c(e); + n.call(this, e), + o.call(this, e), + (this.allowHalfOpen = !0), + e && + (!1 === e.readable && (this.readable = !1), + !1 === e.writable && (this.writable = !1), + !1 === e.allowHalfOpen && + ((this.allowHalfOpen = !1), this.once('end', g))); + } + function g() { + this._writableState.ended || process.nextTick(l, this); + } + function l(e) { + e.end(); + } + Object.defineProperty(c.prototype, 'writableHighWaterMark', { + enumerable: !1, + get: function () { + return this._writableState.highWaterMark; + }, + }), + Object.defineProperty(c.prototype, 'writableBuffer', { + enumerable: !1, + get: function () { + return this._writableState && this._writableState.getBuffer(); + }, + }), + Object.defineProperty(c.prototype, 'writableLength', { + enumerable: !1, + get: function () { + return this._writableState.length; + }, + }), + Object.defineProperty(c.prototype, 'destroyed', { + enumerable: !1, + get: function () { + return ( + void 0 !== this._readableState && + void 0 !== this._writableState && + this._readableState.destroyed && + this._writableState.destroyed + ); + }, + set: function (e) { + void 0 !== this._readableState && + void 0 !== this._writableState && + ((this._readableState.destroyed = e), + (this._writableState.destroyed = e)); + }, + }); + }, + 52444: (e, t, r) => { + 'use strict'; + e.exports = n; + var A = r(54801); + function n(e) { + if (!(this instanceof n)) return new n(e); + A.call(this, e); + } + r(85870)(n, A), + (n.prototype._transform = function (e, t, r) { + r(null, e); + }); + }, + 58020: (e, t, r) => { + 'use strict'; + var A; + (e.exports = w), (w.ReadableState = m); + r(28614).EventEmitter; + var n = function (e, t) { + return e.listeners(t).length; + }, + o = r(49298), + i = r(64293).Buffer, + s = global.Uint8Array || function () {}; + var a, + c = r(31669); + a = c && c.debuglog ? c.debuglog('stream') : function () {}; + var g, + l, + u = r(43117), + h = r(32340), + p = r(77433).getHighWaterMark, + d = r(20663).q, + C = d.ERR_INVALID_ARG_TYPE, + f = d.ERR_STREAM_PUSH_AFTER_EOF, + I = d.ERR_METHOD_NOT_IMPLEMENTED, + E = d.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, + B = r(39138).emitExperimentalWarning; + r(85870)(w, o); + var y = ['error', 'close', 'destroy', 'pause', 'resume']; + function m(e, t, n) { + (A = A || r(72434)), + (e = e || {}), + 'boolean' != typeof n && (n = t instanceof A), + (this.objectMode = !!e.objectMode), + n && (this.objectMode = this.objectMode || !!e.readableObjectMode), + (this.highWaterMark = p(this, e, 'readableHighWaterMark', n)), + (this.buffer = new u()), + (this.length = 0), + (this.pipes = null), + (this.pipesCount = 0), + (this.flowing = null), + (this.ended = !1), + (this.endEmitted = !1), + (this.reading = !1), + (this.sync = !0), + (this.needReadable = !1), + (this.emittedReadable = !1), + (this.readableListening = !1), + (this.resumeScheduled = !1), + (this.paused = !0), + (this.emitClose = !1 !== e.emitClose), + (this.destroyed = !1), + (this.defaultEncoding = e.defaultEncoding || 'utf8'), + (this.awaitDrain = 0), + (this.readingMore = !1), + (this.decoder = null), + (this.encoding = null), + e.encoding && + (g || (g = r(69538).s), + (this.decoder = new g(e.encoding)), + (this.encoding = e.encoding)); + } + function w(e) { + if (((A = A || r(72434)), !(this instanceof w))) return new w(e); + var t = this instanceof A; + (this._readableState = new m(e, this, t)), + (this.readable = !0), + e && + ('function' == typeof e.read && (this._read = e.read), + 'function' == typeof e.destroy && (this._destroy = e.destroy)), + o.call(this); + } + function Q(e, t, r, A, n) { + a('readableAddChunk', t); + var o, + c = e._readableState; + if (null === t) + (c.reading = !1), + (function (e, t) { + if (t.ended) return; + if (t.decoder) { + var r = t.decoder.end(); + r && + r.length && + (t.buffer.push(r), + (t.length += t.objectMode ? 1 : r.length)); + } + (t.ended = !0), + t.sync + ? v(e) + : ((t.needReadable = !1), + t.emittedReadable || ((t.emittedReadable = !0), S(e))); + })(e, c); + else if ( + (n || + (o = (function (e, t) { + var r; + (A = t), + i.isBuffer(A) || + A instanceof s || + 'string' == typeof t || + void 0 === t || + e.objectMode || + (r = new C('chunk', ['string', 'Buffer', 'Uint8Array'], t)); + var A; + return r; + })(c, t)), + o) + ) + e.emit('error', o); + else if (c.objectMode || (t && t.length > 0)) + if ( + ('string' == typeof t || + c.objectMode || + Object.getPrototypeOf(t) === i.prototype || + (t = (function (e) { + return i.from(e); + })(t)), + A) + ) + c.endEmitted ? e.emit('error', new E()) : D(e, c, t, !0); + else if (c.ended) e.emit('error', new f()); + else { + if (c.destroyed) return !1; + (c.reading = !1), + c.decoder && !r + ? ((t = c.decoder.write(t)), + c.objectMode || 0 !== t.length ? D(e, c, t, !1) : k(e, c)) + : D(e, c, t, !1); + } + else A || ((c.reading = !1), k(e, c)); + return !c.ended && (c.length < c.highWaterMark || 0 === c.length); + } + function D(e, t, r, A) { + t.flowing && 0 === t.length && !t.sync + ? ((t.awaitDrain = 0), e.emit('data', r)) + : ((t.length += t.objectMode ? 1 : r.length), + A ? t.buffer.unshift(r) : t.buffer.push(r), + t.needReadable && v(e)), + k(e, t); + } + Object.defineProperty(w.prototype, 'destroyed', { + enumerable: !1, + get: function () { + return ( + void 0 !== this._readableState && this._readableState.destroyed + ); + }, + set: function (e) { + this._readableState && (this._readableState.destroyed = e); + }, + }), + (w.prototype.destroy = h.destroy), + (w.prototype._undestroy = h.undestroy), + (w.prototype._destroy = function (e, t) { + t(e); + }), + (w.prototype.push = function (e, t) { + var r, + A = this._readableState; + return ( + A.objectMode + ? (r = !0) + : 'string' == typeof e && + ((t = t || A.defaultEncoding) !== A.encoding && + ((e = i.from(e, t)), (t = '')), + (r = !0)), + Q(this, e, t, !1, r) + ); + }), + (w.prototype.unshift = function (e) { + return Q(this, e, null, !0, !1); + }), + (w.prototype.isPaused = function () { + return !1 === this._readableState.flowing; + }), + (w.prototype.setEncoding = function (e) { + return ( + g || (g = r(69538).s), + (this._readableState.decoder = new g(e)), + (this._readableState.encoding = this._readableState.decoder.encoding), + this + ); + }); + function b(e, t) { + return e <= 0 || (0 === t.length && t.ended) + ? 0 + : t.objectMode + ? 1 + : e != e + ? t.flowing && t.length + ? t.buffer.head.data.length + : t.length + : (e > t.highWaterMark && + (t.highWaterMark = (function (e) { + return ( + e >= 8388608 + ? (e = 8388608) + : (e--, + (e |= e >>> 1), + (e |= e >>> 2), + (e |= e >>> 4), + (e |= e >>> 8), + (e |= e >>> 16), + e++), + e + ); + })(e)), + e <= t.length + ? e + : t.ended + ? t.length + : ((t.needReadable = !0), 0)); + } + function v(e) { + var t = e._readableState; + (t.needReadable = !1), + t.emittedReadable || + (a('emitReadable', t.flowing), + (t.emittedReadable = !0), + process.nextTick(S, e)); + } + function S(e) { + var t = e._readableState; + a('emitReadable_', t.destroyed, t.length, t.ended), + t.destroyed || (!t.length && !t.ended) || e.emit('readable'), + (t.needReadable = + !t.flowing && !t.ended && t.length <= t.highWaterMark), + R(e); + } + function k(e, t) { + t.readingMore || ((t.readingMore = !0), process.nextTick(N, e, t)); + } + function N(e, t) { + for ( + var r = t.length; + !t.reading && + !t.ended && + t.length < t.highWaterMark && + (a('maybeReadMore read 0'), e.read(0), r !== t.length); + + ) + r = t.length; + t.readingMore = !1; + } + function F(e) { + var t = e._readableState; + (t.readableListening = e.listenerCount('readable') > 0), + t.resumeScheduled && !t.paused + ? (t.flowing = !0) + : e.listenerCount('data') > 0 && e.resume(); + } + function K(e) { + a('readable nexttick read 0'), e.read(0); + } + function M(e, t) { + a('resume', t.reading), + t.reading || e.read(0), + (t.resumeScheduled = !1), + e.emit('resume'), + R(e), + t.flowing && !t.reading && e.read(0); + } + function R(e) { + var t = e._readableState; + for (a('flow', t.flowing); t.flowing && null !== e.read(); ); + } + function x(e, t) { + return 0 === t.length + ? null + : (t.objectMode + ? (r = t.buffer.shift()) + : !e || e >= t.length + ? ((r = t.decoder + ? t.buffer.join('') + : 1 === t.buffer.length + ? t.buffer.first() + : t.buffer.concat(t.length)), + t.buffer.clear()) + : (r = t.buffer.consume(e, t.decoder)), + r); + var r; + } + function L(e) { + var t = e._readableState; + a('endReadable', t.endEmitted), + t.endEmitted || ((t.ended = !0), process.nextTick(P, t, e)); + } + function P(e, t) { + a('endReadableNT', e.endEmitted, e.length), + e.endEmitted || + 0 !== e.length || + ((e.endEmitted = !0), (t.readable = !1), t.emit('end')); + } + function O(e, t) { + for (var r = 0, A = e.length; r < A; r++) if (e[r] === t) return r; + return -1; + } + (w.prototype.read = function (e) { + a('read', e), (e = parseInt(e, 10)); + var t = this._readableState, + r = e; + if ( + (0 !== e && (t.emittedReadable = !1), + 0 === e && + t.needReadable && + ((0 !== t.highWaterMark + ? t.length >= t.highWaterMark + : t.length > 0) || + t.ended)) + ) + return ( + a('read: emitReadable', t.length, t.ended), + 0 === t.length && t.ended ? L(this) : v(this), + null + ); + if (0 === (e = b(e, t)) && t.ended) + return 0 === t.length && L(this), null; + var A, + n = t.needReadable; + return ( + a('need readable', n), + (0 === t.length || t.length - e < t.highWaterMark) && + a('length less than watermark', (n = !0)), + t.ended || t.reading + ? a('reading or ended', (n = !1)) + : n && + (a('do read'), + (t.reading = !0), + (t.sync = !0), + 0 === t.length && (t.needReadable = !0), + this._read(t.highWaterMark), + (t.sync = !1), + t.reading || (e = b(r, t))), + null === (A = e > 0 ? x(e, t) : null) + ? ((t.needReadable = !0), (e = 0)) + : ((t.length -= e), (t.awaitDrain = 0)), + 0 === t.length && + (t.ended || (t.needReadable = !0), r !== e && t.ended && L(this)), + null !== A && this.emit('data', A), + A + ); + }), + (w.prototype._read = function (e) { + this.emit('error', new I('_read()')); + }), + (w.prototype.pipe = function (e, t) { + var r = this, + A = this._readableState; + switch (A.pipesCount) { + case 0: + A.pipes = e; + break; + case 1: + A.pipes = [A.pipes, e]; + break; + default: + A.pipes.push(e); + } + (A.pipesCount += 1), a('pipe count=%d opts=%j', A.pipesCount, t); + var o = + (!t || !1 !== t.end) && + e !== process.stdout && + e !== process.stderr + ? s + : d; + function i(t, n) { + a('onunpipe'), + t === r && + n && + !1 === n.hasUnpiped && + ((n.hasUnpiped = !0), + a('cleanup'), + e.removeListener('close', h), + e.removeListener('finish', p), + e.removeListener('drain', c), + e.removeListener('error', u), + e.removeListener('unpipe', i), + r.removeListener('end', s), + r.removeListener('end', d), + r.removeListener('data', l), + (g = !0), + !A.awaitDrain || + (e._writableState && !e._writableState.needDrain) || + c()); + } + function s() { + a('onend'), e.end(); + } + A.endEmitted ? process.nextTick(o) : r.once('end', o), + e.on('unpipe', i); + var c = (function (e) { + return function () { + var t = e._readableState; + a('pipeOnDrain', t.awaitDrain), + t.awaitDrain && t.awaitDrain--, + 0 === t.awaitDrain && + n(e, 'data') && + ((t.flowing = !0), R(e)); + }; + })(r); + e.on('drain', c); + var g = !1; + function l(t) { + a('ondata'); + var n = e.write(t); + a('dest.write', n), + !1 === n && + (((1 === A.pipesCount && A.pipes === e) || + (A.pipesCount > 1 && -1 !== O(A.pipes, e))) && + !g && + (a('false write response, pause', A.awaitDrain), + A.awaitDrain++), + r.pause()); + } + function u(t) { + a('onerror', t), + d(), + e.removeListener('error', u), + 0 === n(e, 'error') && e.emit('error', t); + } + function h() { + e.removeListener('finish', p), d(); + } + function p() { + a('onfinish'), e.removeListener('close', h), d(); + } + function d() { + a('unpipe'), r.unpipe(e); + } + return ( + r.on('data', l), + (function (e, t, r) { + if ('function' == typeof e.prependListener) + return e.prependListener(t, r); + e._events && e._events[t] + ? Array.isArray(e._events[t]) + ? e._events[t].unshift(r) + : (e._events[t] = [r, e._events[t]]) + : e.on(t, r); + })(e, 'error', u), + e.once('close', h), + e.once('finish', p), + e.emit('pipe', r), + A.flowing || (a('pipe resume'), r.resume()), + e + ); + }), + (w.prototype.unpipe = function (e) { + var t = this._readableState, + r = { hasUnpiped: !1 }; + if (0 === t.pipesCount) return this; + if (1 === t.pipesCount) + return ( + (e && e !== t.pipes) || + (e || (e = t.pipes), + (t.pipes = null), + (t.pipesCount = 0), + (t.flowing = !1), + e && e.emit('unpipe', this, r)), + this + ); + if (!e) { + var A = t.pipes, + n = t.pipesCount; + (t.pipes = null), (t.pipesCount = 0), (t.flowing = !1); + for (var o = 0; o < n; o++) + A[o].emit('unpipe', this, { hasUnpiped: !1 }); + return this; + } + var i = O(t.pipes, e); + return ( + -1 === i || + (t.pipes.splice(i, 1), + (t.pipesCount -= 1), + 1 === t.pipesCount && (t.pipes = t.pipes[0]), + e.emit('unpipe', this, r)), + this + ); + }), + (w.prototype.on = function (e, t) { + var r = o.prototype.on.call(this, e, t), + A = this._readableState; + return ( + 'data' === e + ? ((A.readableListening = this.listenerCount('readable') > 0), + !1 !== A.flowing && this.resume()) + : 'readable' === e && + (A.endEmitted || + A.readableListening || + ((A.readableListening = A.needReadable = !0), + (A.flowing = !1), + (A.emittedReadable = !1), + a('on readable', A.length, A.reading), + A.length + ? v(this) + : A.reading || process.nextTick(K, this))), + r + ); + }), + (w.prototype.addListener = w.prototype.on), + (w.prototype.removeListener = function (e, t) { + var r = o.prototype.removeListener.call(this, e, t); + return 'readable' === e && process.nextTick(F, this), r; + }), + (w.prototype.removeAllListeners = function (e) { + var t = o.prototype.removeAllListeners.apply(this, arguments); + return ( + ('readable' !== e && void 0 !== e) || process.nextTick(F, this), t + ); + }), + (w.prototype.resume = function () { + var e = this._readableState; + return ( + e.flowing || + (a('resume'), + (e.flowing = !e.readableListening), + (function (e, t) { + t.resumeScheduled || + ((t.resumeScheduled = !0), process.nextTick(M, e, t)); + })(this, e)), + (e.paused = !1), + this + ); + }), + (w.prototype.pause = function () { + return ( + a('call pause flowing=%j', this._readableState.flowing), + !1 !== this._readableState.flowing && + (a('pause'), + (this._readableState.flowing = !1), + this.emit('pause')), + (this._readableState.paused = !0), + this + ); + }), + (w.prototype.wrap = function (e) { + var t = this, + r = this._readableState, + A = !1; + for (var n in (e.on('end', function () { + if ((a('wrapped end'), r.decoder && !r.ended)) { + var e = r.decoder.end(); + e && e.length && t.push(e); + } + t.push(null); + }), + e.on('data', function (n) { + (a('wrapped data'), + r.decoder && (n = r.decoder.write(n)), + r.objectMode && null == n) || + ((r.objectMode || (n && n.length)) && + (t.push(n) || ((A = !0), e.pause()))); + }), + e)) + void 0 === this[n] && + 'function' == typeof e[n] && + (this[n] = (function (t) { + return function () { + return e[t].apply(e, arguments); + }; + })(n)); + for (var o = 0; o < y.length; o++) + e.on(y[o], this.emit.bind(this, y[o])); + return ( + (this._read = function (t) { + a('wrapped _read', t), A && ((A = !1), e.resume()); + }), + this + ); + }), + 'function' == typeof Symbol && + (w.prototype[Symbol.asyncIterator] = function () { + return ( + B('Readable[Symbol.asyncIterator]'), + void 0 === l && (l = r(4245)), + l(this) + ); + }), + Object.defineProperty(w.prototype, 'readableHighWaterMark', { + enumerable: !1, + get: function () { + return this._readableState.highWaterMark; + }, + }), + Object.defineProperty(w.prototype, 'readableBuffer', { + enumerable: !1, + get: function () { + return this._readableState && this._readableState.buffer; + }, + }), + Object.defineProperty(w.prototype, 'readableFlowing', { + enumerable: !1, + get: function () { + return this._readableState.flowing; + }, + set: function (e) { + this._readableState && (this._readableState.flowing = e); + }, + }), + (w._fromList = x), + Object.defineProperty(w.prototype, 'readableLength', { + enumerable: !1, + get: function () { + return this._readableState.length; + }, + }); + }, + 54801: (e, t, r) => { + 'use strict'; + e.exports = g; + var A = r(20663).q, + n = A.ERR_METHOD_NOT_IMPLEMENTED, + o = A.ERR_MULTIPLE_CALLBACK, + i = A.ERR_TRANSFORM_ALREADY_TRANSFORMING, + s = A.ERR_TRANSFORM_WITH_LENGTH_0, + a = r(72434); + function c(e, t) { + var r = this._transformState; + r.transforming = !1; + var A = r.writecb; + if (null === A) return this.emit('error', new o()); + (r.writechunk = null), + (r.writecb = null), + null != t && this.push(t), + A(e); + var n = this._readableState; + (n.reading = !1), + (n.needReadable || n.length < n.highWaterMark) && + this._read(n.highWaterMark); + } + function g(e) { + if (!(this instanceof g)) return new g(e); + a.call(this, e), + (this._transformState = { + afterTransform: c.bind(this), + needTransform: !1, + transforming: !1, + writecb: null, + writechunk: null, + writeencoding: null, + }), + (this._readableState.needReadable = !0), + (this._readableState.sync = !1), + e && + ('function' == typeof e.transform && + (this._transform = e.transform), + 'function' == typeof e.flush && (this._flush = e.flush)), + this.on('prefinish', l); + } + function l() { + var e = this; + 'function' != typeof this._flush || this._readableState.destroyed + ? u(this, null, null) + : this._flush(function (t, r) { + u(e, t, r); + }); + } + function u(e, t, r) { + if (t) return e.emit('error', t); + if ((null != r && e.push(r), e._writableState.length)) throw new s(); + if (e._transformState.transforming) throw new i(); + return e.push(null); + } + r(85870)(g, a), + (g.prototype.push = function (e, t) { + return ( + (this._transformState.needTransform = !1), + a.prototype.push.call(this, e, t) + ); + }), + (g.prototype._transform = function (e, t, r) { + r(new n('_transform()')); + }), + (g.prototype._write = function (e, t, r) { + var A = this._transformState; + if ( + ((A.writecb = r), + (A.writechunk = e), + (A.writeencoding = t), + !A.transforming) + ) { + var n = this._readableState; + (A.needTransform || + n.needReadable || + n.length < n.highWaterMark) && + this._read(n.highWaterMark); + } + }), + (g.prototype._read = function (e) { + var t = this._transformState; + null === t.writechunk || t.transforming + ? (t.needTransform = !0) + : ((t.transforming = !0), + this._transform( + t.writechunk, + t.writeencoding, + t.afterTransform + )); + }), + (g.prototype._destroy = function (e, t) { + a.prototype._destroy.call(this, e, function (e) { + t(e); + }); + }); + }, + 6729: (e, t, r) => { + 'use strict'; + function A(e) { + var t = this; + (this.next = null), + (this.entry = null), + (this.finish = function () { + !(function (e, t, r) { + var A = e.entry; + e.entry = null; + for (; A; ) { + var n = A.callback; + t.pendingcb--, n(r), (A = A.next); + } + t.corkedRequestsFree.next = e; + })(t, e); + }); + } + var n; + (e.exports = w), (w.WritableState = m); + var o = { deprecate: r(73212) }, + i = r(49298), + s = r(64293).Buffer, + a = global.Uint8Array || function () {}; + var c, + g = r(32340), + l = r(77433).getHighWaterMark, + u = r(20663).q, + h = u.ERR_INVALID_ARG_TYPE, + p = u.ERR_METHOD_NOT_IMPLEMENTED, + d = u.ERR_MULTIPLE_CALLBACK, + C = u.ERR_STREAM_CANNOT_PIPE, + f = u.ERR_STREAM_DESTROYED, + I = u.ERR_STREAM_NULL_VALUES, + E = u.ERR_STREAM_WRITE_AFTER_END, + B = u.ERR_UNKNOWN_ENCODING; + function y() {} + function m(e, t, o) { + (n = n || r(72434)), + (e = e || {}), + 'boolean' != typeof o && (o = t instanceof n), + (this.objectMode = !!e.objectMode), + o && (this.objectMode = this.objectMode || !!e.writableObjectMode), + (this.highWaterMark = l(this, e, 'writableHighWaterMark', o)), + (this.finalCalled = !1), + (this.needDrain = !1), + (this.ending = !1), + (this.ended = !1), + (this.finished = !1), + (this.destroyed = !1); + var i = !1 === e.decodeStrings; + (this.decodeStrings = !i), + (this.defaultEncoding = e.defaultEncoding || 'utf8'), + (this.length = 0), + (this.writing = !1), + (this.corked = 0), + (this.sync = !0), + (this.bufferProcessing = !1), + (this.onwrite = function (e) { + !(function (e, t) { + var r = e._writableState, + A = r.sync, + n = r.writecb; + if ('function' != typeof n) throw new d(); + if ( + ((function (e) { + (e.writing = !1), + (e.writecb = null), + (e.length -= e.writelen), + (e.writelen = 0); + })(r), + t) + ) + !(function (e, t, r, A, n) { + --t.pendingcb, + r + ? (process.nextTick(n, A), + process.nextTick(k, e, t), + (e._writableState.errorEmitted = !0), + e.emit('error', A)) + : (n(A), + (e._writableState.errorEmitted = !0), + e.emit('error', A), + k(e, t)); + })(e, r, A, t, n); + else { + var o = v(r) || e.destroyed; + o || + r.corked || + r.bufferProcessing || + !r.bufferedRequest || + b(e, r), + A ? process.nextTick(D, e, r, o, n) : D(e, r, o, n); + } + })(t, e); + }), + (this.writecb = null), + (this.writelen = 0), + (this.bufferedRequest = null), + (this.lastBufferedRequest = null), + (this.pendingcb = 0), + (this.prefinished = !1), + (this.errorEmitted = !1), + (this.emitClose = !1 !== e.emitClose), + (this.bufferedRequestCount = 0), + (this.corkedRequestsFree = new A(this)); + } + function w(e) { + var t = this instanceof (n = n || r(72434)); + if (!t && !c.call(w, this)) return new w(e); + (this._writableState = new m(e, this, t)), + (this.writable = !0), + e && + ('function' == typeof e.write && (this._write = e.write), + 'function' == typeof e.writev && (this._writev = e.writev), + 'function' == typeof e.destroy && (this._destroy = e.destroy), + 'function' == typeof e.final && (this._final = e.final)), + i.call(this); + } + function Q(e, t, r, A, n, o, i) { + (t.writelen = A), + (t.writecb = i), + (t.writing = !0), + (t.sync = !0), + t.destroyed + ? t.onwrite(new f('write')) + : r + ? e._writev(n, t.onwrite) + : e._write(n, o, t.onwrite), + (t.sync = !1); + } + function D(e, t, r, A) { + r || + (function (e, t) { + 0 === t.length && + t.needDrain && + ((t.needDrain = !1), e.emit('drain')); + })(e, t), + t.pendingcb--, + A(), + k(e, t); + } + function b(e, t) { + t.bufferProcessing = !0; + var r = t.bufferedRequest; + if (e._writev && r && r.next) { + var n = t.bufferedRequestCount, + o = new Array(n), + i = t.corkedRequestsFree; + i.entry = r; + for (var s = 0, a = !0; r; ) + (o[s] = r), r.isBuf || (a = !1), (r = r.next), (s += 1); + (o.allBuffers = a), + Q(e, t, !0, t.length, o, '', i.finish), + t.pendingcb++, + (t.lastBufferedRequest = null), + i.next + ? ((t.corkedRequestsFree = i.next), (i.next = null)) + : (t.corkedRequestsFree = new A(t)), + (t.bufferedRequestCount = 0); + } else { + for (; r; ) { + var c = r.chunk, + g = r.encoding, + l = r.callback; + if ( + (Q(e, t, !1, t.objectMode ? 1 : c.length, c, g, l), + (r = r.next), + t.bufferedRequestCount--, + t.writing) + ) + break; + } + null === r && (t.lastBufferedRequest = null); + } + (t.bufferedRequest = r), (t.bufferProcessing = !1); + } + function v(e) { + return ( + e.ending && + 0 === e.length && + null === e.bufferedRequest && + !e.finished && + !e.writing + ); + } + function S(e, t) { + e._final(function (r) { + t.pendingcb--, + r && e.emit('error', r), + (t.prefinished = !0), + e.emit('prefinish'), + k(e, t); + }); + } + function k(e, t) { + var r = v(t); + return ( + r && + (!(function (e, t) { + t.prefinished || + t.finalCalled || + ('function' != typeof e._final || t.destroyed + ? ((t.prefinished = !0), e.emit('prefinish')) + : (t.pendingcb++, + (t.finalCalled = !0), + process.nextTick(S, e, t))); + })(e, t), + 0 === t.pendingcb && ((t.finished = !0), e.emit('finish'))), + r + ); + } + r(85870)(w, i), + (m.prototype.getBuffer = function () { + for (var e = this.bufferedRequest, t = []; e; ) + t.push(e), (e = e.next); + return t; + }), + (function () { + try { + Object.defineProperty(m.prototype, 'buffer', { + get: o.deprecate( + function () { + return this.getBuffer(); + }, + '_writableState.buffer is deprecated. Use _writableState.getBuffer instead.', + 'DEP0003' + ), + }); + } catch (e) {} + })(), + 'function' == typeof Symbol && + Symbol.hasInstance && + 'function' == typeof Function.prototype[Symbol.hasInstance] + ? ((c = Function.prototype[Symbol.hasInstance]), + Object.defineProperty(w, Symbol.hasInstance, { + value: function (e) { + return ( + !!c.call(this, e) || + (this === w && e && e._writableState instanceof m) + ); + }, + })) + : (c = function (e) { + return e instanceof this; + }), + (w.prototype.pipe = function () { + this.emit('error', new C()); + }), + (w.prototype.write = function (e, t, r) { + var A, + n = this._writableState, + o = !1, + i = !n.objectMode && ((A = e), s.isBuffer(A) || A instanceof a); + return ( + i && + !s.isBuffer(e) && + (e = (function (e) { + return s.from(e); + })(e)), + 'function' == typeof t && ((r = t), (t = null)), + i ? (t = 'buffer') : t || (t = n.defaultEncoding), + 'function' != typeof r && (r = y), + n.ending + ? (function (e, t) { + var r = new E(); + e.emit('error', r), process.nextTick(t, r); + })(this, r) + : (i || + (function (e, t, r, A) { + var n; + return ( + null === r + ? (n = new I()) + : 'string' == typeof r || + t.objectMode || + (n = new h('chunk', ['string', 'Buffer'], r)), + !n || (e.emit('error', n), process.nextTick(A, n), !1) + ); + })(this, n, e, r)) && + (n.pendingcb++, + (o = (function (e, t, r, A, n, o) { + if (!r) { + var i = (function (e, t, r) { + e.objectMode || + !1 === e.decodeStrings || + 'string' != typeof t || + (t = s.from(t, r)); + return t; + })(t, A, n); + A !== i && ((r = !0), (n = 'buffer'), (A = i)); + } + var a = t.objectMode ? 1 : A.length; + t.length += a; + var c = t.length < t.highWaterMark; + c || (t.needDrain = !0); + if (t.writing || t.corked) { + var g = t.lastBufferedRequest; + (t.lastBufferedRequest = { + chunk: A, + encoding: n, + isBuf: r, + callback: o, + next: null, + }), + g + ? (g.next = t.lastBufferedRequest) + : (t.bufferedRequest = t.lastBufferedRequest), + (t.bufferedRequestCount += 1); + } else Q(e, t, !1, a, A, n, o); + return c; + })(this, n, i, e, t, r))), + o + ); + }), + (w.prototype.cork = function () { + this._writableState.corked++; + }), + (w.prototype.uncork = function () { + var e = this._writableState; + e.corked && + (e.corked--, + e.writing || + e.corked || + e.bufferProcessing || + !e.bufferedRequest || + b(this, e)); + }), + (w.prototype.setDefaultEncoding = function (e) { + if ( + ('string' == typeof e && (e = e.toLowerCase()), + !( + [ + 'hex', + 'utf8', + 'utf-8', + 'ascii', + 'binary', + 'base64', + 'ucs2', + 'ucs-2', + 'utf16le', + 'utf-16le', + 'raw', + ].indexOf((e + '').toLowerCase()) > -1 + )) + ) + throw new B(e); + return (this._writableState.defaultEncoding = e), this; + }), + Object.defineProperty(w.prototype, 'writableBuffer', { + enumerable: !1, + get: function () { + return this._writableState && this._writableState.getBuffer(); + }, + }), + Object.defineProperty(w.prototype, 'writableHighWaterMark', { + enumerable: !1, + get: function () { + return this._writableState.highWaterMark; + }, + }), + (w.prototype._write = function (e, t, r) { + r(new p('_write()')); + }), + (w.prototype._writev = null), + (w.prototype.end = function (e, t, r) { + var A = this._writableState; + return ( + 'function' == typeof e + ? ((r = e), (e = null), (t = null)) + : 'function' == typeof t && ((r = t), (t = null)), + null != e && this.write(e, t), + A.corked && ((A.corked = 1), this.uncork()), + A.ending || + (function (e, t, r) { + (t.ending = !0), + k(e, t), + r && + (t.finished ? process.nextTick(r) : e.once('finish', r)); + (t.ended = !0), (e.writable = !1); + })(this, A, r), + this + ); + }), + Object.defineProperty(w.prototype, 'writableLength', { + enumerable: !1, + get: function () { + return this._writableState.length; + }, + }), + Object.defineProperty(w.prototype, 'destroyed', { + enumerable: !1, + get: function () { + return ( + void 0 !== this._writableState && this._writableState.destroyed + ); + }, + set: function (e) { + this._writableState && (this._writableState.destroyed = e); + }, + }), + (w.prototype.destroy = g.destroy), + (w.prototype._undestroy = g.undestroy), + (w.prototype._destroy = function (e, t) { + t(e); + }); + }, + 4245: (e, t, r) => { + 'use strict'; + var A; + function n(e, t, r) { + return ( + t in e + ? Object.defineProperty(e, t, { + value: r, + enumerable: !0, + configurable: !0, + writable: !0, + }) + : (e[t] = r), + e + ); + } + var o = r(91327), + i = Symbol('lastResolve'), + s = Symbol('lastReject'), + a = Symbol('error'), + c = Symbol('ended'), + g = Symbol('lastPromise'), + l = Symbol('handlePromise'), + u = Symbol('stream'); + function h(e, t) { + return { value: e, done: t }; + } + function p(e) { + var t = e[i]; + if (null !== t) { + var r = e[u].read(); + null !== r && + ((e[g] = null), (e[i] = null), (e[s] = null), t(h(r, !1))); + } + } + function d(e) { + process.nextTick(p, e); + } + var C = Object.getPrototypeOf(function () {}), + f = Object.setPrototypeOf( + (n( + (A = { + get stream() { + return this[u]; + }, + next: function () { + var e = this, + t = this[a]; + if (null !== t) return Promise.reject(t); + if (this[c]) return Promise.resolve(h(null, !0)); + if (this[u].destroyed) + return new Promise(function (t, r) { + process.nextTick(function () { + e[a] ? r(e[a]) : t(h(null, !0)); + }); + }); + var r, + A = this[g]; + if (A) + r = new Promise( + (function (e, t) { + return function (r, A) { + e.then(function () { + t[l](r, A); + }, A); + }; + })(A, this) + ); + else { + var n = this[u].read(); + if (null !== n) return Promise.resolve(h(n, !1)); + r = new Promise(this[l]); + } + return (this[g] = r), r; + }, + }), + Symbol.asyncIterator, + function () { + return this; + } + ), + n(A, 'return', function () { + var e = this; + return new Promise(function (t, r) { + e[u].destroy(null, function (e) { + e ? r(e) : t(h(null, !0)); + }); + }); + }), + A), + C + ); + e.exports = function (e) { + var t, + r = Object.create( + f, + (n((t = {}), u, { value: e, writable: !0 }), + n(t, i, { value: null, writable: !0 }), + n(t, s, { value: null, writable: !0 }), + n(t, a, { value: null, writable: !0 }), + n(t, c, { value: e._readableState.endEmitted, writable: !0 }), + n(t, g, { value: null, writable: !0 }), + n(t, l, { + value: function (e, t) { + var A = r[u].read(); + A + ? ((r[g] = null), (r[i] = null), (r[s] = null), e(h(A, !1))) + : ((r[i] = e), (r[s] = t)); + }, + writable: !0, + }), + t) + ); + return ( + o(e, function (e) { + if (e && 'ERR_STREAM_PREMATURE_CLOSE' !== e.code) { + var t = r[s]; + return ( + null !== t && + ((r[g] = null), (r[i] = null), (r[s] = null), t(e)), + void (r[a] = e) + ); + } + var A = r[i]; + null !== A && + ((r[g] = null), (r[i] = null), (r[s] = null), A(h(null, !0))), + (r[c] = !0); + }), + e.on('readable', d.bind(null, r)), + r + ); + }; + }, + 43117: (e, t, r) => { + 'use strict'; + function A(e, t, r) { + return ( + t in e + ? Object.defineProperty(e, t, { + value: r, + enumerable: !0, + configurable: !0, + writable: !0, + }) + : (e[t] = r), + e + ); + } + var n = r(64293).Buffer, + o = r(31669).inspect, + i = (o && o.custom) || 'inspect'; + e.exports = (function () { + function e() { + (this.head = null), (this.tail = null), (this.length = 0); + } + var t = e.prototype; + return ( + (t.push = function (e) { + var t = { data: e, next: null }; + this.length > 0 ? (this.tail.next = t) : (this.head = t), + (this.tail = t), + ++this.length; + }), + (t.unshift = function (e) { + var t = { data: e, next: this.head }; + 0 === this.length && (this.tail = t), + (this.head = t), + ++this.length; + }), + (t.shift = function () { + if (0 !== this.length) { + var e = this.head.data; + return ( + 1 === this.length + ? (this.head = this.tail = null) + : (this.head = this.head.next), + --this.length, + e + ); + } + }), + (t.clear = function () { + (this.head = this.tail = null), (this.length = 0); + }), + (t.join = function (e) { + if (0 === this.length) return ''; + for (var t = this.head, r = '' + t.data; (t = t.next); ) + r += e + t.data; + return r; + }), + (t.concat = function (e) { + if (0 === this.length) return n.alloc(0); + for ( + var t, r, A, o = n.allocUnsafe(e >>> 0), i = this.head, s = 0; + i; + + ) + (t = i.data), + (r = o), + (A = s), + n.prototype.copy.call(t, r, A), + (s += i.data.length), + (i = i.next); + return o; + }), + (t.consume = function (e, t) { + var r; + return ( + e < this.head.data.length + ? ((r = this.head.data.slice(0, e)), + (this.head.data = this.head.data.slice(e))) + : (r = + e === this.head.data.length + ? this.shift() + : t + ? this._getString(e) + : this._getBuffer(e)), + r + ); + }), + (t.first = function () { + return this.head.data; + }), + (t._getString = function (e) { + var t = this.head, + r = 1, + A = t.data; + for (e -= A.length; (t = t.next); ) { + var n = t.data, + o = e > n.length ? n.length : e; + if ( + (o === n.length ? (A += n) : (A += n.slice(0, e)), + 0 === (e -= o)) + ) { + o === n.length + ? (++r, + t.next + ? (this.head = t.next) + : (this.head = this.tail = null)) + : ((this.head = t), (t.data = n.slice(o))); + break; + } + ++r; + } + return (this.length -= r), A; + }), + (t._getBuffer = function (e) { + var t = n.allocUnsafe(e), + r = this.head, + A = 1; + for (r.data.copy(t), e -= r.data.length; (r = r.next); ) { + var o = r.data, + i = e > o.length ? o.length : e; + if ((o.copy(t, t.length - e, 0, i), 0 === (e -= i))) { + i === o.length + ? (++A, + r.next + ? (this.head = r.next) + : (this.head = this.tail = null)) + : ((this.head = r), (r.data = o.slice(i))); + break; + } + ++A; + } + return (this.length -= A), t; + }), + (t[i] = function (e, t) { + return o( + this, + (function (e) { + for (var t = 1; t < arguments.length; t++) { + var r = null != arguments[t] ? arguments[t] : {}, + n = Object.keys(r); + 'function' == typeof Object.getOwnPropertySymbols && + (n = n.concat( + Object.getOwnPropertySymbols(r).filter(function (e) { + return Object.getOwnPropertyDescriptor( + r, + e + ).enumerable; + }) + )), + n.forEach(function (t) { + A(e, t, r[t]); + }); + } + return e; + })({}, t, { depth: 0, customInspect: !1 }) + ); + }), + e + ); + })(); + }, + 32340: (e) => { + 'use strict'; + function t(e, t) { + A(e, t), r(e); + } + function r(e) { + (e._writableState && !e._writableState.emitClose) || + (e._readableState && !e._readableState.emitClose) || + e.emit('close'); + } + function A(e, t) { + e.emit('error', t); + } + e.exports = { + destroy: function (e, n) { + var o = this, + i = this._readableState && this._readableState.destroyed, + s = this._writableState && this._writableState.destroyed; + return i || s + ? (n + ? n(e) + : !e || + (this._writableState && this._writableState.errorEmitted) || + process.nextTick(A, this, e), + this) + : (this._readableState && (this._readableState.destroyed = !0), + this._writableState && (this._writableState.destroyed = !0), + this._destroy(e || null, function (e) { + !n && e + ? (process.nextTick(t, o, e), + o._writableState && (o._writableState.errorEmitted = !0)) + : n + ? (process.nextTick(r, o), n(e)) + : process.nextTick(r, o); + }), + this); + }, + undestroy: function () { + this._readableState && + ((this._readableState.destroyed = !1), + (this._readableState.reading = !1), + (this._readableState.ended = !1), + (this._readableState.endEmitted = !1)), + this._writableState && + ((this._writableState.destroyed = !1), + (this._writableState.ended = !1), + (this._writableState.ending = !1), + (this._writableState.finalCalled = !1), + (this._writableState.prefinished = !1), + (this._writableState.finished = !1), + (this._writableState.errorEmitted = !1)); + }, + }; + }, + 91327: (e, t, r) => { + 'use strict'; + var A = r(20663).q.ERR_STREAM_PREMATURE_CLOSE; + function n() {} + e.exports = function e(t, r, o) { + if ('function' == typeof r) return e(t, null, r); + r || (r = {}), + (o = (function (e) { + var t = !1; + return function (r) { + t || ((t = !0), e.call(this, r)); + }; + })(o || n)); + var i = t._writableState, + s = t._readableState, + a = r.readable || (!1 !== r.readable && t.readable), + c = r.writable || (!1 !== r.writable && t.writable), + g = function () { + t.writable || l(); + }, + l = function () { + (c = !1), a || o.call(t); + }, + u = function () { + (a = !1), c || o.call(t); + }, + h = function (e) { + o.call(t, e); + }, + p = function () { + return (!a || (s && s.ended)) && (!c || (i && i.ended)) + ? void 0 + : o.call(t, new A()); + }, + d = function () { + t.req.on('finish', l); + }; + return ( + !(function (e) { + return e.setHeader && 'function' == typeof e.abort; + })(t) + ? c && !i && (t.on('end', g), t.on('close', g)) + : (t.on('complete', l), + t.on('abort', p), + t.req ? d() : t.on('request', d)), + t.on('end', u), + t.on('finish', l), + !1 !== r.error && t.on('error', h), + t.on('close', p), + function () { + t.removeListener('complete', l), + t.removeListener('abort', p), + t.removeListener('request', d), + t.req && t.req.removeListener('finish', l), + t.removeListener('end', g), + t.removeListener('close', g), + t.removeListener('finish', l), + t.removeListener('end', u), + t.removeListener('error', h), + t.removeListener('close', p); + } + ); + }; + }, + 4939: (e, t, r) => { + 'use strict'; + var A; + var n = r(20663).q, + o = n.ERR_MISSING_ARGS, + i = n.ERR_STREAM_DESTROYED; + function s(e) { + if (e) throw e; + } + function a(e, t, n, o) { + o = (function (e) { + var t = !1; + return function () { + t || ((t = !0), e.apply(void 0, arguments)); + }; + })(o); + var s = !1; + e.on('close', function () { + s = !0; + }), + void 0 === A && (A = r(91327)), + A(e, { readable: t, writable: n }, function (e) { + if (e) return o(e); + (s = !0), o(); + }); + var a = !1; + return function (t) { + if (!s && !a) + return ( + (a = !0), + (function (e) { + return e.setHeader && 'function' == typeof e.abort; + })(e) + ? e.abort() + : 'function' == typeof e.destroy + ? e.destroy() + : void o(t || new i('pipe')) + ); + }; + } + function c(e) { + e(); + } + function g(e, t) { + return e.pipe(t); + } + function l(e) { + return e.length + ? 'function' != typeof e[e.length - 1] + ? s + : e.pop() + : s; + } + e.exports = function () { + for (var e = arguments.length, t = new Array(e), r = 0; r < e; r++) + t[r] = arguments[r]; + var A, + n = l(t); + if ((Array.isArray(t[0]) && (t = t[0]), t.length < 2)) + throw new o('streams'); + var i = t.map(function (e, r) { + var o = r < t.length - 1; + return a(e, o, r > 0, function (e) { + A || (A = e), e && i.forEach(c), o || (i.forEach(c), n(A)); + }); + }); + return t.reduce(g); + }; + }, + 77433: (e, t, r) => { + 'use strict'; + var A = r(20663).q.ERR_INVALID_OPT_VALUE; + e.exports = { + getHighWaterMark: function (e, t, r, n) { + var o = (function (e, t, r) { + return null != e.highWaterMark + ? e.highWaterMark + : t + ? e[r] + : null; + })(t, n, r); + if (null != o) { + if (!isFinite(o) || Math.floor(o) !== o || o < 0) + throw new A(n ? r : 'highWaterMark', o); + return Math.floor(o); + } + return e.objectMode ? 16 : 16384; + }, + }; + }, + 49298: (e, t, r) => { + e.exports = r(92413); + }, + 86897: (e, t, r) => { + var A = r(92413); + 'disable' === process.env.READABLE_STREAM && A + ? ((e.exports = A.Readable), + Object.assign(e.exports, A), + (e.exports.Stream = A)) + : (((t = e.exports = r(58020)).Stream = A || t), + (t.Readable = t), + (t.Writable = r(6729)), + (t.Duplex = r(72434)), + (t.Transform = r(54801)), + (t.PassThrough = r(52444)), + (t.finished = r(91327)), + (t.pipeline = r(4939))); + }, + 19476: (e, t, r) => { + 'use strict'; + const A = r(4016); + e.exports = (e = {}) => + new Promise((t, r) => { + const n = A.connect(e, () => { + e.resolveSocket + ? (n.off('error', r), + t({ alpnProtocol: n.alpnProtocol, socket: n })) + : (n.destroy(), t({ alpnProtocol: n.alpnProtocol })); + }); + n.on('error', r); + }); + }, + 48491: (e, t, r) => { + 'use strict'; + const A = r(92413).Readable, + n = r(55737); + e.exports = class extends A { + constructor(e, t, r, A) { + if ('number' != typeof e) + throw new TypeError('Argument `statusCode` should be a number'); + if ('object' != typeof t) + throw new TypeError('Argument `headers` should be an object'); + if (!(r instanceof Buffer)) + throw new TypeError('Argument `body` should be a buffer'); + if ('string' != typeof A) + throw new TypeError('Argument `url` should be a string'); + super(), + (this.statusCode = e), + (this.headers = n(t)), + (this.body = r), + (this.url = A); + } + _read() { + this.push(this.body), this.push(null); + } + }; + }, + 2383: (e) => { + 'use strict'; + e.exports = function (e) { + var t = new e(), + r = t; + return { + get: function () { + var A = t; + return ( + A.next ? (t = A.next) : ((t = new e()), (r = t)), + (A.next = null), + A + ); + }, + release: function (e) { + (r.next = e), (r = e); + }, + }; + }; + }, + 69078: (e) => { + e.exports = function (e, t) { + var r, + A, + n, + o = !0; + Array.isArray(e) + ? ((r = []), (A = e.length)) + : ((n = Object.keys(e)), (r = {}), (A = n.length)); + function i(e) { + function A() { + t && t(e, r), (t = null); + } + o ? process.nextTick(A) : A(); + } + function s(e, t, n) { + (r[e] = n), (0 == --A || t) && i(t); + } + A + ? n + ? n.forEach(function (t) { + e[t](function (e, r) { + s(t, e, r); + }); + }) + : e.forEach(function (e, t) { + e(function (e, r) { + s(t, e, r); + }); + }) + : i(null); + o = !1; + }; + }, + 13499: (e, t, r) => { + var A = r(64293), + n = A.Buffer; + function o(e, t) { + for (var r in e) t[r] = e[r]; + } + function i(e, t, r) { + return n(e, t, r); + } + n.from && n.alloc && n.allocUnsafe && n.allocUnsafeSlow + ? (e.exports = A) + : (o(A, t), (t.Buffer = i)), + o(n, i), + (i.from = function (e, t, r) { + if ('number' == typeof e) + throw new TypeError('Argument must not be a number'); + return n(e, t, r); + }), + (i.alloc = function (e, t, r) { + if ('number' != typeof e) + throw new TypeError('Argument must be a number'); + var A = n(e); + return ( + void 0 !== t + ? 'string' == typeof r + ? A.fill(t, r) + : A.fill(t) + : A.fill(0), + A + ); + }), + (i.allocUnsafe = function (e) { + if ('number' != typeof e) + throw new TypeError('Argument must be a number'); + return n(e); + }), + (i.allocUnsafeSlow = function (e) { + if ('number' != typeof e) + throw new TypeError('Argument must be a number'); + return A.SlowBuffer(e); + }); + }, + 95584: (e, t) => { + var r; + (t = e.exports = l), + (r = + 'object' == typeof process && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) + ? function () { + var e = Array.prototype.slice.call(arguments, 0); + e.unshift('SEMVER'), console.log.apply(console, e); + } + : function () {}), + (t.SEMVER_SPEC_VERSION = '2.0.0'); + var A = Number.MAX_SAFE_INTEGER || 9007199254740991, + n = (t.re = []), + o = (t.src = []), + i = (t.tokens = {}), + s = 0; + function a(e) { + i[e] = s++; + } + a('NUMERICIDENTIFIER'), + (o[i.NUMERICIDENTIFIER] = '0|[1-9]\\d*'), + a('NUMERICIDENTIFIERLOOSE'), + (o[i.NUMERICIDENTIFIERLOOSE] = '[0-9]+'), + a('NONNUMERICIDENTIFIER'), + (o[i.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'), + a('MAINVERSION'), + (o[i.MAINVERSION] = + '(' + + o[i.NUMERICIDENTIFIER] + + ')\\.(' + + o[i.NUMERICIDENTIFIER] + + ')\\.(' + + o[i.NUMERICIDENTIFIER] + + ')'), + a('MAINVERSIONLOOSE'), + (o[i.MAINVERSIONLOOSE] = + '(' + + o[i.NUMERICIDENTIFIERLOOSE] + + ')\\.(' + + o[i.NUMERICIDENTIFIERLOOSE] + + ')\\.(' + + o[i.NUMERICIDENTIFIERLOOSE] + + ')'), + a('PRERELEASEIDENTIFIER'), + (o[i.PRERELEASEIDENTIFIER] = + '(?:' + + o[i.NUMERICIDENTIFIER] + + '|' + + o[i.NONNUMERICIDENTIFIER] + + ')'), + a('PRERELEASEIDENTIFIERLOOSE'), + (o[i.PRERELEASEIDENTIFIERLOOSE] = + '(?:' + + o[i.NUMERICIDENTIFIERLOOSE] + + '|' + + o[i.NONNUMERICIDENTIFIER] + + ')'), + a('PRERELEASE'), + (o[i.PRERELEASE] = + '(?:-(' + + o[i.PRERELEASEIDENTIFIER] + + '(?:\\.' + + o[i.PRERELEASEIDENTIFIER] + + ')*))'), + a('PRERELEASELOOSE'), + (o[i.PRERELEASELOOSE] = + '(?:-?(' + + o[i.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + + o[i.PRERELEASEIDENTIFIERLOOSE] + + ')*))'), + a('BUILDIDENTIFIER'), + (o[i.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'), + a('BUILD'), + (o[i.BUILD] = + '(?:\\+(' + + o[i.BUILDIDENTIFIER] + + '(?:\\.' + + o[i.BUILDIDENTIFIER] + + ')*))'), + a('FULL'), + a('FULLPLAIN'), + (o[i.FULLPLAIN] = + 'v?' + o[i.MAINVERSION] + o[i.PRERELEASE] + '?' + o[i.BUILD] + '?'), + (o[i.FULL] = '^' + o[i.FULLPLAIN] + '$'), + a('LOOSEPLAIN'), + (o[i.LOOSEPLAIN] = + '[v=\\s]*' + + o[i.MAINVERSIONLOOSE] + + o[i.PRERELEASELOOSE] + + '?' + + o[i.BUILD] + + '?'), + a('LOOSE'), + (o[i.LOOSE] = '^' + o[i.LOOSEPLAIN] + '$'), + a('GTLT'), + (o[i.GTLT] = '((?:<|>)?=?)'), + a('XRANGEIDENTIFIERLOOSE'), + (o[i.XRANGEIDENTIFIERLOOSE] = + o[i.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'), + a('XRANGEIDENTIFIER'), + (o[i.XRANGEIDENTIFIER] = o[i.NUMERICIDENTIFIER] + '|x|X|\\*'), + a('XRANGEPLAIN'), + (o[i.XRANGEPLAIN] = + '[v=\\s]*(' + + o[i.XRANGEIDENTIFIER] + + ')(?:\\.(' + + o[i.XRANGEIDENTIFIER] + + ')(?:\\.(' + + o[i.XRANGEIDENTIFIER] + + ')(?:' + + o[i.PRERELEASE] + + ')?' + + o[i.BUILD] + + '?)?)?'), + a('XRANGEPLAINLOOSE'), + (o[i.XRANGEPLAINLOOSE] = + '[v=\\s]*(' + + o[i.XRANGEIDENTIFIERLOOSE] + + ')(?:\\.(' + + o[i.XRANGEIDENTIFIERLOOSE] + + ')(?:\\.(' + + o[i.XRANGEIDENTIFIERLOOSE] + + ')(?:' + + o[i.PRERELEASELOOSE] + + ')?' + + o[i.BUILD] + + '?)?)?'), + a('XRANGE'), + (o[i.XRANGE] = '^' + o[i.GTLT] + '\\s*' + o[i.XRANGEPLAIN] + '$'), + a('XRANGELOOSE'), + (o[i.XRANGELOOSE] = + '^' + o[i.GTLT] + '\\s*' + o[i.XRANGEPLAINLOOSE] + '$'), + a('COERCE'), + (o[i.COERCE] = + '(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])'), + a('COERCERTL'), + (n[i.COERCERTL] = new RegExp(o[i.COERCE], 'g')), + a('LONETILDE'), + (o[i.LONETILDE] = '(?:~>?)'), + a('TILDETRIM'), + (o[i.TILDETRIM] = '(\\s*)' + o[i.LONETILDE] + '\\s+'), + (n[i.TILDETRIM] = new RegExp(o[i.TILDETRIM], 'g')); + a('TILDE'), + (o[i.TILDE] = '^' + o[i.LONETILDE] + o[i.XRANGEPLAIN] + '$'), + a('TILDELOOSE'), + (o[i.TILDELOOSE] = + '^' + o[i.LONETILDE] + o[i.XRANGEPLAINLOOSE] + '$'), + a('LONECARET'), + (o[i.LONECARET] = '(?:\\^)'), + a('CARETTRIM'), + (o[i.CARETTRIM] = '(\\s*)' + o[i.LONECARET] + '\\s+'), + (n[i.CARETTRIM] = new RegExp(o[i.CARETTRIM], 'g')); + a('CARET'), + (o[i.CARET] = '^' + o[i.LONECARET] + o[i.XRANGEPLAIN] + '$'), + a('CARETLOOSE'), + (o[i.CARETLOOSE] = + '^' + o[i.LONECARET] + o[i.XRANGEPLAINLOOSE] + '$'), + a('COMPARATORLOOSE'), + (o[i.COMPARATORLOOSE] = + '^' + o[i.GTLT] + '\\s*(' + o[i.LOOSEPLAIN] + ')$|^$'), + a('COMPARATOR'), + (o[i.COMPARATOR] = + '^' + o[i.GTLT] + '\\s*(' + o[i.FULLPLAIN] + ')$|^$'), + a('COMPARATORTRIM'), + (o[i.COMPARATORTRIM] = + '(\\s*)' + + o[i.GTLT] + + '\\s*(' + + o[i.LOOSEPLAIN] + + '|' + + o[i.XRANGEPLAIN] + + ')'), + (n[i.COMPARATORTRIM] = new RegExp(o[i.COMPARATORTRIM], 'g')); + a('HYPHENRANGE'), + (o[i.HYPHENRANGE] = + '^\\s*(' + + o[i.XRANGEPLAIN] + + ')\\s+-\\s+(' + + o[i.XRANGEPLAIN] + + ')\\s*$'), + a('HYPHENRANGELOOSE'), + (o[i.HYPHENRANGELOOSE] = + '^\\s*(' + + o[i.XRANGEPLAINLOOSE] + + ')\\s+-\\s+(' + + o[i.XRANGEPLAINLOOSE] + + ')\\s*$'), + a('STAR'), + (o[i.STAR] = '(<|>)?=?\\s*\\*'); + for (var c = 0; c < s; c++) + r(c, o[c]), n[c] || (n[c] = new RegExp(o[c])); + function g(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof l) + ) + return e; + if ('string' != typeof e) return null; + if (e.length > 256) return null; + if (!(t.loose ? n[i.LOOSE] : n[i.FULL]).test(e)) return null; + try { + return new l(e, t); + } catch (e) { + return null; + } + } + function l(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof l) + ) { + if (e.loose === t.loose) return e; + e = e.version; + } else if ('string' != typeof e) + throw new TypeError('Invalid Version: ' + e); + if (e.length > 256) + throw new TypeError('version is longer than 256 characters'); + if (!(this instanceof l)) return new l(e, t); + r('SemVer', e, t), (this.options = t), (this.loose = !!t.loose); + var o = e.trim().match(t.loose ? n[i.LOOSE] : n[i.FULL]); + if (!o) throw new TypeError('Invalid Version: ' + e); + if ( + ((this.raw = e), + (this.major = +o[1]), + (this.minor = +o[2]), + (this.patch = +o[3]), + this.major > A || this.major < 0) + ) + throw new TypeError('Invalid major version'); + if (this.minor > A || this.minor < 0) + throw new TypeError('Invalid minor version'); + if (this.patch > A || this.patch < 0) + throw new TypeError('Invalid patch version'); + o[4] + ? (this.prerelease = o[4].split('.').map(function (e) { + if (/^[0-9]+$/.test(e)) { + var t = +e; + if (t >= 0 && t < A) return t; + } + return e; + })) + : (this.prerelease = []), + (this.build = o[5] ? o[5].split('.') : []), + this.format(); + } + (t.parse = g), + (t.valid = function (e, t) { + var r = g(e, t); + return r ? r.version : null; + }), + (t.clean = function (e, t) { + var r = g(e.trim().replace(/^[=v]+/, ''), t); + return r ? r.version : null; + }), + (t.SemVer = l), + (l.prototype.format = function () { + return ( + (this.version = this.major + '.' + this.minor + '.' + this.patch), + this.prerelease.length && + (this.version += '-' + this.prerelease.join('.')), + this.version + ); + }), + (l.prototype.toString = function () { + return this.version; + }), + (l.prototype.compare = function (e) { + return ( + r('SemVer.compare', this.version, this.options, e), + e instanceof l || (e = new l(e, this.options)), + this.compareMain(e) || this.comparePre(e) + ); + }), + (l.prototype.compareMain = function (e) { + return ( + e instanceof l || (e = new l(e, this.options)), + h(this.major, e.major) || + h(this.minor, e.minor) || + h(this.patch, e.patch) + ); + }), + (l.prototype.comparePre = function (e) { + if ( + (e instanceof l || (e = new l(e, this.options)), + this.prerelease.length && !e.prerelease.length) + ) + return -1; + if (!this.prerelease.length && e.prerelease.length) return 1; + if (!this.prerelease.length && !e.prerelease.length) return 0; + var t = 0; + do { + var A = this.prerelease[t], + n = e.prerelease[t]; + if ( + (r('prerelease compare', t, A, n), void 0 === A && void 0 === n) + ) + return 0; + if (void 0 === n) return 1; + if (void 0 === A) return -1; + if (A !== n) return h(A, n); + } while (++t); + }), + (l.prototype.compareBuild = function (e) { + e instanceof l || (e = new l(e, this.options)); + var t = 0; + do { + var A = this.build[t], + n = e.build[t]; + if ( + (r('prerelease compare', t, A, n), void 0 === A && void 0 === n) + ) + return 0; + if (void 0 === n) return 1; + if (void 0 === A) return -1; + if (A !== n) return h(A, n); + } while (++t); + }), + (l.prototype.inc = function (e, t) { + switch (e) { + case 'premajor': + (this.prerelease.length = 0), + (this.patch = 0), + (this.minor = 0), + this.major++, + this.inc('pre', t); + break; + case 'preminor': + (this.prerelease.length = 0), + (this.patch = 0), + this.minor++, + this.inc('pre', t); + break; + case 'prepatch': + (this.prerelease.length = 0), + this.inc('patch', t), + this.inc('pre', t); + break; + case 'prerelease': + 0 === this.prerelease.length && this.inc('patch', t), + this.inc('pre', t); + break; + case 'major': + (0 === this.minor && + 0 === this.patch && + 0 !== this.prerelease.length) || + this.major++, + (this.minor = 0), + (this.patch = 0), + (this.prerelease = []); + break; + case 'minor': + (0 === this.patch && 0 !== this.prerelease.length) || + this.minor++, + (this.patch = 0), + (this.prerelease = []); + break; + case 'patch': + 0 === this.prerelease.length && this.patch++, + (this.prerelease = []); + break; + case 'pre': + if (0 === this.prerelease.length) this.prerelease = [0]; + else { + for (var r = this.prerelease.length; --r >= 0; ) + 'number' == typeof this.prerelease[r] && + (this.prerelease[r]++, (r = -2)); + -1 === r && this.prerelease.push(0); + } + t && + (this.prerelease[0] === t + ? isNaN(this.prerelease[1]) && (this.prerelease = [t, 0]) + : (this.prerelease = [t, 0])); + break; + default: + throw new Error('invalid increment argument: ' + e); + } + return this.format(), (this.raw = this.version), this; + }), + (t.inc = function (e, t, r, A) { + 'string' == typeof r && ((A = r), (r = void 0)); + try { + return new l(e, r).inc(t, A).version; + } catch (e) { + return null; + } + }), + (t.diff = function (e, t) { + if (f(e, t)) return null; + var r = g(e), + A = g(t), + n = ''; + if (r.prerelease.length || A.prerelease.length) { + n = 'pre'; + var o = 'prerelease'; + } + for (var i in r) + if ( + ('major' === i || 'minor' === i || 'patch' === i) && + r[i] !== A[i] + ) + return n + i; + return o; + }), + (t.compareIdentifiers = h); + var u = /^[0-9]+$/; + function h(e, t) { + var r = u.test(e), + A = u.test(t); + return ( + r && A && ((e = +e), (t = +t)), + e === t ? 0 : r && !A ? -1 : A && !r ? 1 : e < t ? -1 : 1 + ); + } + function p(e, t, r) { + return new l(e, r).compare(new l(t, r)); + } + function d(e, t, r) { + return p(e, t, r) > 0; + } + function C(e, t, r) { + return p(e, t, r) < 0; + } + function f(e, t, r) { + return 0 === p(e, t, r); + } + function I(e, t, r) { + return 0 !== p(e, t, r); + } + function E(e, t, r) { + return p(e, t, r) >= 0; + } + function B(e, t, r) { + return p(e, t, r) <= 0; + } + function y(e, t, r, A) { + switch (t) { + case '===': + return ( + 'object' == typeof e && (e = e.version), + 'object' == typeof r && (r = r.version), + e === r + ); + case '!==': + return ( + 'object' == typeof e && (e = e.version), + 'object' == typeof r && (r = r.version), + e !== r + ); + case '': + case '=': + case '==': + return f(e, r, A); + case '!=': + return I(e, r, A); + case '>': + return d(e, r, A); + case '>=': + return E(e, r, A); + case '<': + return C(e, r, A); + case '<=': + return B(e, r, A); + default: + throw new TypeError('Invalid operator: ' + t); + } + } + function m(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof m) + ) { + if (e.loose === !!t.loose) return e; + e = e.value; + } + if (!(this instanceof m)) return new m(e, t); + r('comparator', e, t), + (this.options = t), + (this.loose = !!t.loose), + this.parse(e), + this.semver === w + ? (this.value = '') + : (this.value = this.operator + this.semver.version), + r('comp', this); + } + (t.rcompareIdentifiers = function (e, t) { + return h(t, e); + }), + (t.major = function (e, t) { + return new l(e, t).major; + }), + (t.minor = function (e, t) { + return new l(e, t).minor; + }), + (t.patch = function (e, t) { + return new l(e, t).patch; + }), + (t.compare = p), + (t.compareLoose = function (e, t) { + return p(e, t, !0); + }), + (t.compareBuild = function (e, t, r) { + var A = new l(e, r), + n = new l(t, r); + return A.compare(n) || A.compareBuild(n); + }), + (t.rcompare = function (e, t, r) { + return p(t, e, r); + }), + (t.sort = function (e, r) { + return e.sort(function (e, A) { + return t.compareBuild(e, A, r); + }); + }), + (t.rsort = function (e, r) { + return e.sort(function (e, A) { + return t.compareBuild(A, e, r); + }); + }), + (t.gt = d), + (t.lt = C), + (t.eq = f), + (t.neq = I), + (t.gte = E), + (t.lte = B), + (t.cmp = y), + (t.Comparator = m); + var w = {}; + function Q(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof Q) + ) + return e.loose === !!t.loose && + e.includePrerelease === !!t.includePrerelease + ? e + : new Q(e.raw, t); + if (e instanceof m) return new Q(e.value, t); + if (!(this instanceof Q)) return new Q(e, t); + if ( + ((this.options = t), + (this.loose = !!t.loose), + (this.includePrerelease = !!t.includePrerelease), + (this.raw = e), + (this.set = e + .split(/\s*\|\|\s*/) + .map(function (e) { + return this.parseRange(e.trim()); + }, this) + .filter(function (e) { + return e.length; + })), + !this.set.length) + ) + throw new TypeError('Invalid SemVer Range: ' + e); + this.format(); + } + function D(e, t) { + for (var r = !0, A = e.slice(), n = A.pop(); r && A.length; ) + (r = A.every(function (e) { + return n.intersects(e, t); + })), + (n = A.pop()); + return r; + } + function b(e) { + return !e || 'x' === e.toLowerCase() || '*' === e; + } + function v(e, t, r, A, n, o, i, s, a, c, g, l, u) { + return ( + (t = b(r) + ? '' + : b(A) + ? '>=' + r + '.0.0' + : b(n) + ? '>=' + r + '.' + A + '.0' + : '>=' + t) + + ' ' + + (s = b(a) + ? '' + : b(c) + ? '<' + (+a + 1) + '.0.0' + : b(g) + ? '<' + a + '.' + (+c + 1) + '.0' + : l + ? '<=' + a + '.' + c + '.' + g + '-' + l + : '<=' + s) + ).trim(); + } + function S(e, t, A) { + for (var n = 0; n < e.length; n++) if (!e[n].test(t)) return !1; + if (t.prerelease.length && !A.includePrerelease) { + for (n = 0; n < e.length; n++) + if ( + (r(e[n].semver), + e[n].semver !== w && e[n].semver.prerelease.length > 0) + ) { + var o = e[n].semver; + if ( + o.major === t.major && + o.minor === t.minor && + o.patch === t.patch + ) + return !0; + } + return !1; + } + return !0; + } + function k(e, t, r) { + try { + t = new Q(t, r); + } catch (e) { + return !1; + } + return t.test(e); + } + function N(e, t, r, A) { + var n, o, i, s, a; + switch (((e = new l(e, A)), (t = new Q(t, A)), r)) { + case '>': + (n = d), (o = B), (i = C), (s = '>'), (a = '>='); + break; + case '<': + (n = C), (o = E), (i = d), (s = '<'), (a = '<='); + break; + default: + throw new TypeError('Must provide a hilo val of "<" or ">"'); + } + if (k(e, t, A)) return !1; + for (var c = 0; c < t.set.length; ++c) { + var g = t.set[c], + u = null, + h = null; + if ( + (g.forEach(function (e) { + e.semver === w && (e = new m('>=0.0.0')), + (u = u || e), + (h = h || e), + n(e.semver, u.semver, A) + ? (u = e) + : i(e.semver, h.semver, A) && (h = e); + }), + u.operator === s || u.operator === a) + ) + return !1; + if ((!h.operator || h.operator === s) && o(e, h.semver)) return !1; + if (h.operator === a && i(e, h.semver)) return !1; + } + return !0; + } + (m.prototype.parse = function (e) { + var t = this.options.loose ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], + r = e.match(t); + if (!r) throw new TypeError('Invalid comparator: ' + e); + (this.operator = void 0 !== r[1] ? r[1] : ''), + '=' === this.operator && (this.operator = ''), + r[2] + ? (this.semver = new l(r[2], this.options.loose)) + : (this.semver = w); + }), + (m.prototype.toString = function () { + return this.value; + }), + (m.prototype.test = function (e) { + if ( + (r('Comparator.test', e, this.options.loose), + this.semver === w || e === w) + ) + return !0; + if ('string' == typeof e) + try { + e = new l(e, this.options); + } catch (e) { + return !1; + } + return y(e, this.operator, this.semver, this.options); + }), + (m.prototype.intersects = function (e, t) { + if (!(e instanceof m)) + throw new TypeError('a Comparator is required'); + var r; + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + '' === this.operator) + ) + return ( + '' === this.value || + ((r = new Q(e.value, t)), k(this.value, r, t)) + ); + if ('' === e.operator) + return ( + '' === e.value || + ((r = new Q(this.value, t)), k(e.semver, r, t)) + ); + var A = !( + ('>=' !== this.operator && '>' !== this.operator) || + ('>=' !== e.operator && '>' !== e.operator) + ), + n = !( + ('<=' !== this.operator && '<' !== this.operator) || + ('<=' !== e.operator && '<' !== e.operator) + ), + o = this.semver.version === e.semver.version, + i = !( + ('>=' !== this.operator && '<=' !== this.operator) || + ('>=' !== e.operator && '<=' !== e.operator) + ), + s = + y(this.semver, '<', e.semver, t) && + ('>=' === this.operator || '>' === this.operator) && + ('<=' === e.operator || '<' === e.operator), + a = + y(this.semver, '>', e.semver, t) && + ('<=' === this.operator || '<' === this.operator) && + ('>=' === e.operator || '>' === e.operator); + return A || n || (o && i) || s || a; + }), + (t.Range = Q), + (Q.prototype.format = function () { + return ( + (this.range = this.set + .map(function (e) { + return e.join(' ').trim(); + }) + .join('||') + .trim()), + this.range + ); + }), + (Q.prototype.toString = function () { + return this.range; + }), + (Q.prototype.parseRange = function (e) { + var t = this.options.loose; + e = e.trim(); + var A = t ? n[i.HYPHENRANGELOOSE] : n[i.HYPHENRANGE]; + (e = e.replace(A, v)), + r('hyphen replace', e), + (e = e.replace(n[i.COMPARATORTRIM], '$1$2$3')), + r('comparator trim', e, n[i.COMPARATORTRIM]), + (e = (e = (e = e.replace(n[i.TILDETRIM], '$1~')).replace( + n[i.CARETTRIM], + '$1^' + )) + .split(/\s+/) + .join(' ')); + var o = t ? n[i.COMPARATORLOOSE] : n[i.COMPARATOR], + s = e + .split(' ') + .map(function (e) { + return (function (e, t) { + return ( + r('comp', e, t), + (e = (function (e, t) { + return e + .trim() + .split(/\s+/) + .map(function (e) { + return (function (e, t) { + r('caret', e, t); + var A = t.loose ? n[i.CARETLOOSE] : n[i.CARET]; + return e.replace(A, function (t, A, n, o, i) { + var s; + return ( + r('caret', e, t, A, n, o, i), + b(A) + ? (s = '') + : b(n) + ? (s = + '>=' + A + '.0.0 <' + (+A + 1) + '.0.0') + : b(o) + ? (s = + '0' === A + ? '>=' + + A + + '.' + + n + + '.0 <' + + A + + '.' + + (+n + 1) + + '.0' + : '>=' + + A + + '.' + + n + + '.0 <' + + (+A + 1) + + '.0.0') + : i + ? (r('replaceCaret pr', i), + (s = + '0' === A + ? '0' === n + ? '>=' + + A + + '.' + + n + + '.' + + o + + '-' + + i + + ' <' + + A + + '.' + + n + + '.' + + (+o + 1) + : '>=' + + A + + '.' + + n + + '.' + + o + + '-' + + i + + ' <' + + A + + '.' + + (+n + 1) + + '.0' + : '>=' + + A + + '.' + + n + + '.' + + o + + '-' + + i + + ' <' + + (+A + 1) + + '.0.0')) + : (r('no pr'), + (s = + '0' === A + ? '0' === n + ? '>=' + + A + + '.' + + n + + '.' + + o + + ' <' + + A + + '.' + + n + + '.' + + (+o + 1) + : '>=' + + A + + '.' + + n + + '.' + + o + + ' <' + + A + + '.' + + (+n + 1) + + '.0' + : '>=' + + A + + '.' + + n + + '.' + + o + + ' <' + + (+A + 1) + + '.0.0')), + r('caret return', s), + s + ); + }); + })(e, t); + }) + .join(' '); + })(e, t)), + r('caret', e), + (e = (function (e, t) { + return e + .trim() + .split(/\s+/) + .map(function (e) { + return (function (e, t) { + var A = t.loose ? n[i.TILDELOOSE] : n[i.TILDE]; + return e.replace(A, function (t, A, n, o, i) { + var s; + return ( + r('tilde', e, t, A, n, o, i), + b(A) + ? (s = '') + : b(n) + ? (s = + '>=' + A + '.0.0 <' + (+A + 1) + '.0.0') + : b(o) + ? (s = + '>=' + + A + + '.' + + n + + '.0 <' + + A + + '.' + + (+n + 1) + + '.0') + : i + ? (r('replaceTilde pr', i), + (s = + '>=' + + A + + '.' + + n + + '.' + + o + + '-' + + i + + ' <' + + A + + '.' + + (+n + 1) + + '.0')) + : (s = + '>=' + + A + + '.' + + n + + '.' + + o + + ' <' + + A + + '.' + + (+n + 1) + + '.0'), + r('tilde return', s), + s + ); + }); + })(e, t); + }) + .join(' '); + })(e, t)), + r('tildes', e), + (e = (function (e, t) { + return ( + r('replaceXRanges', e, t), + e + .split(/\s+/) + .map(function (e) { + return (function (e, t) { + e = e.trim(); + var A = t.loose + ? n[i.XRANGELOOSE] + : n[i.XRANGE]; + return e.replace(A, function ( + A, + n, + o, + i, + s, + a + ) { + r('xRange', e, A, n, o, i, s, a); + var c = b(o), + g = c || b(i), + l = g || b(s), + u = l; + return ( + '=' === n && u && (n = ''), + (a = t.includePrerelease ? '-0' : ''), + c + ? (A = + '>' === n || '<' === n + ? '<0.0.0-0' + : '*') + : n && u + ? (g && (i = 0), + (s = 0), + '>' === n + ? ((n = '>='), + g + ? ((o = +o + 1), (i = 0), (s = 0)) + : ((i = +i + 1), (s = 0))) + : '<=' === n && + ((n = '<'), + g ? (o = +o + 1) : (i = +i + 1)), + (A = n + o + '.' + i + '.' + s + a)) + : g + ? (A = + '>=' + + o + + '.0.0' + + a + + ' <' + + (+o + 1) + + '.0.0' + + a) + : l && + (A = + '>=' + + o + + '.' + + i + + '.0' + + a + + ' <' + + o + + '.' + + (+i + 1) + + '.0' + + a), + r('xRange return', A), + A + ); + }); + })(e, t); + }) + .join(' ') + ); + })(e, t)), + r('xrange', e), + (e = (function (e, t) { + return ( + r('replaceStars', e, t), + e.trim().replace(n[i.STAR], '') + ); + })(e, t)), + r('stars', e), + e + ); + })(e, this.options); + }, this) + .join(' ') + .split(/\s+/); + return ( + this.options.loose && + (s = s.filter(function (e) { + return !!e.match(o); + })), + (s = s.map(function (e) { + return new m(e, this.options); + }, this)) + ); + }), + (Q.prototype.intersects = function (e, t) { + if (!(e instanceof Q)) throw new TypeError('a Range is required'); + return this.set.some(function (r) { + return ( + D(r, t) && + e.set.some(function (e) { + return ( + D(e, t) && + r.every(function (r) { + return e.every(function (e) { + return r.intersects(e, t); + }); + }) + ); + }) + ); + }); + }), + (t.toComparators = function (e, t) { + return new Q(e, t).set.map(function (e) { + return e + .map(function (e) { + return e.value; + }) + .join(' ') + .trim() + .split(' '); + }); + }), + (Q.prototype.test = function (e) { + if (!e) return !1; + if ('string' == typeof e) + try { + e = new l(e, this.options); + } catch (e) { + return !1; + } + for (var t = 0; t < this.set.length; t++) + if (S(this.set[t], e, this.options)) return !0; + return !1; + }), + (t.satisfies = k), + (t.maxSatisfying = function (e, t, r) { + var A = null, + n = null; + try { + var o = new Q(t, r); + } catch (e) { + return null; + } + return ( + e.forEach(function (e) { + o.test(e) && + ((A && -1 !== n.compare(e)) || (n = new l((A = e), r))); + }), + A + ); + }), + (t.minSatisfying = function (e, t, r) { + var A = null, + n = null; + try { + var o = new Q(t, r); + } catch (e) { + return null; + } + return ( + e.forEach(function (e) { + o.test(e) && + ((A && 1 !== n.compare(e)) || (n = new l((A = e), r))); + }), + A + ); + }), + (t.minVersion = function (e, t) { + e = new Q(e, t); + var r = new l('0.0.0'); + if (e.test(r)) return r; + if (((r = new l('0.0.0-0')), e.test(r))) return r; + r = null; + for (var A = 0; A < e.set.length; ++A) { + e.set[A].forEach(function (e) { + var t = new l(e.semver.version); + switch (e.operator) { + case '>': + 0 === t.prerelease.length + ? t.patch++ + : t.prerelease.push(0), + (t.raw = t.format()); + case '': + case '>=': + (r && !d(r, t)) || (r = t); + break; + case '<': + case '<=': + break; + default: + throw new Error('Unexpected operation: ' + e.operator); + } + }); + } + if (r && e.test(r)) return r; + return null; + }), + (t.validRange = function (e, t) { + try { + return new Q(e, t).range || '*'; + } catch (e) { + return null; + } + }), + (t.ltr = function (e, t, r) { + return N(e, t, '<', r); + }), + (t.gtr = function (e, t, r) { + return N(e, t, '>', r); + }), + (t.outside = N), + (t.prerelease = function (e, t) { + var r = g(e, t); + return r && r.prerelease.length ? r.prerelease : null; + }), + (t.intersects = function (e, t, r) { + return (e = new Q(e, r)), (t = new Q(t, r)), e.intersects(t); + }), + (t.coerce = function (e, t) { + if (e instanceof l) return e; + 'number' == typeof e && (e = String(e)); + if ('string' != typeof e) return null; + var r = null; + if ((t = t || {}).rtl) { + for ( + var A; + (A = n[i.COERCERTL].exec(e)) && + (!r || r.index + r[0].length !== e.length); + + ) + (r && A.index + A[0].length === r.index + r[0].length) || + (r = A), + (n[i.COERCERTL].lastIndex = + A.index + A[1].length + A[2].length); + n[i.COERCERTL].lastIndex = -1; + } else r = e.match(n[i.COERCE]); + if (null === r) return null; + return g(r[2] + '.' + (r[3] || '0') + '.' + (r[4] || '0'), t); + }); + }, + 29069: (e, t, r) => { + const A = Symbol('SemVer ANY'); + class n { + static get ANY() { + return A; + } + constructor(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof n) + ) { + if (e.loose === !!t.loose) return e; + e = e.value; + } + a('comparator', e, t), + (this.options = t), + (this.loose = !!t.loose), + this.parse(e), + this.semver === A + ? (this.value = '') + : (this.value = this.operator + this.semver.version), + a('comp', this); + } + parse(e) { + const t = this.options.loose + ? o[i.COMPARATORLOOSE] + : o[i.COMPARATOR], + r = e.match(t); + if (!r) throw new TypeError('Invalid comparator: ' + e); + (this.operator = void 0 !== r[1] ? r[1] : ''), + '=' === this.operator && (this.operator = ''), + r[2] + ? (this.semver = new c(r[2], this.options.loose)) + : (this.semver = A); + } + toString() { + return this.value; + } + test(e) { + if ( + (a('Comparator.test', e, this.options.loose), + this.semver === A || e === A) + ) + return !0; + if ('string' == typeof e) + try { + e = new c(e, this.options); + } catch (e) { + return !1; + } + return s(e, this.operator, this.semver, this.options); + } + intersects(e, t) { + if (!(e instanceof n)) + throw new TypeError('a Comparator is required'); + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + '' === this.operator) + ) + return '' === this.value || new g(e.value, t).test(this.value); + if ('' === e.operator) + return '' === e.value || new g(this.value, t).test(e.semver); + const r = !( + ('>=' !== this.operator && '>' !== this.operator) || + ('>=' !== e.operator && '>' !== e.operator) + ), + A = !( + ('<=' !== this.operator && '<' !== this.operator) || + ('<=' !== e.operator && '<' !== e.operator) + ), + o = this.semver.version === e.semver.version, + i = !( + ('>=' !== this.operator && '<=' !== this.operator) || + ('>=' !== e.operator && '<=' !== e.operator) + ), + a = + s(this.semver, '<', e.semver, t) && + ('>=' === this.operator || '>' === this.operator) && + ('<=' === e.operator || '<' === e.operator), + c = + s(this.semver, '>', e.semver, t) && + ('<=' === this.operator || '<' === this.operator) && + ('>=' === e.operator || '>' === e.operator); + return r || A || (o && i) || a || c; + } + } + e.exports = n; + const { re: o, t: i } = r(49439), + s = r(38754), + a = r(6029), + c = r(14772), + g = r(73004); + }, + 73004: (e, t, r) => { + class A { + constructor(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof A) + ) + return e.loose === !!t.loose && + e.includePrerelease === !!t.includePrerelease + ? e + : new A(e.raw, t); + if (e instanceof n) + return ( + (this.raw = e.value), (this.set = [[e]]), this.format(), this + ); + if ( + ((this.options = t), + (this.loose = !!t.loose), + (this.includePrerelease = !!t.includePrerelease), + (this.raw = e), + (this.set = e + .split(/\s*\|\|\s*/) + .map((e) => this.parseRange(e.trim())) + .filter((e) => e.length)), + !this.set.length) + ) + throw new TypeError('Invalid SemVer Range: ' + e); + this.format(); + } + format() { + return ( + (this.range = this.set + .map((e) => e.join(' ').trim()) + .join('||') + .trim()), + this.range + ); + } + toString() { + return this.range; + } + parseRange(e) { + const t = this.options.loose; + e = e.trim(); + const r = t ? s[a.HYPHENRANGELOOSE] : s[a.HYPHENRANGE]; + (e = e.replace(r, w(this.options.includePrerelease))), + o('hyphen replace', e), + (e = e.replace(s[a.COMPARATORTRIM], c)), + o('comparator trim', e, s[a.COMPARATORTRIM]), + (e = (e = (e = e.replace(s[a.TILDETRIM], g)).replace( + s[a.CARETTRIM], + l + )) + .split(/\s+/) + .join(' ')); + const A = t ? s[a.COMPARATORLOOSE] : s[a.COMPARATOR]; + return e + .split(' ') + .map((e) => h(e, this.options)) + .join(' ') + .split(/\s+/) + .map((e) => m(e, this.options)) + .filter(this.options.loose ? (e) => !!e.match(A) : () => !0) + .map((e) => new n(e, this.options)); + } + intersects(e, t) { + if (!(e instanceof A)) throw new TypeError('a Range is required'); + return this.set.some( + (r) => + u(r, t) && + e.set.some( + (e) => + u(e, t) && + r.every((r) => e.every((e) => r.intersects(e, t))) + ) + ); + } + test(e) { + if (!e) return !1; + if ('string' == typeof e) + try { + e = new i(e, this.options); + } catch (e) { + return !1; + } + for (let t = 0; t < this.set.length; t++) + if (Q(this.set[t], e, this.options)) return !0; + return !1; + } + } + e.exports = A; + const n = r(29069), + o = r(6029), + i = r(14772), + { + re: s, + t: a, + comparatorTrimReplace: c, + tildeTrimReplace: g, + caretTrimReplace: l, + } = r(49439), + u = (e, t) => { + let r = !0; + const A = e.slice(); + let n = A.pop(); + for (; r && A.length; ) + (r = A.every((e) => n.intersects(e, t))), (n = A.pop()); + return r; + }, + h = (e, t) => ( + o('comp', e, t), + (e = f(e, t)), + o('caret', e), + (e = d(e, t)), + o('tildes', e), + (e = E(e, t)), + o('xrange', e), + (e = y(e, t)), + o('stars', e), + e + ), + p = (e) => !e || 'x' === e.toLowerCase() || '*' === e, + d = (e, t) => + e + .trim() + .split(/\s+/) + .map((e) => C(e, t)) + .join(' '), + C = (e, t) => { + const r = t.loose ? s[a.TILDELOOSE] : s[a.TILDE]; + return e.replace(r, (t, r, A, n, i) => { + let s; + return ( + o('tilde', e, t, r, A, n, i), + p(r) + ? (s = '') + : p(A) + ? (s = `>=${r}.0.0 <${+r + 1}.0.0-0`) + : p(n) + ? (s = `>=${r}.${A}.0 <${r}.${+A + 1}.0-0`) + : i + ? (o('replaceTilde pr', i), + (s = `>=${r}.${A}.${n}-${i} <${r}.${+A + 1}.0-0`)) + : (s = `>=${r}.${A}.${n} <${r}.${+A + 1}.0-0`), + o('tilde return', s), + s + ); + }); + }, + f = (e, t) => + e + .trim() + .split(/\s+/) + .map((e) => I(e, t)) + .join(' '), + I = (e, t) => { + o('caret', e, t); + const r = t.loose ? s[a.CARETLOOSE] : s[a.CARET], + A = t.includePrerelease ? '-0' : ''; + return e.replace(r, (t, r, n, i, s) => { + let a; + return ( + o('caret', e, t, r, n, i, s), + p(r) + ? (a = '') + : p(n) + ? (a = `>=${r}.0.0${A} <${+r + 1}.0.0-0`) + : p(i) + ? (a = + '0' === r + ? `>=${r}.${n}.0${A} <${r}.${+n + 1}.0-0` + : `>=${r}.${n}.0${A} <${+r + 1}.0.0-0`) + : s + ? (o('replaceCaret pr', s), + (a = + '0' === r + ? '0' === n + ? `>=${r}.${n}.${i}-${s} <${r}.${n}.${+i + 1}-0` + : `>=${r}.${n}.${i}-${s} <${r}.${+n + 1}.0-0` + : `>=${r}.${n}.${i}-${s} <${+r + 1}.0.0-0`)) + : (o('no pr'), + (a = + '0' === r + ? '0' === n + ? `>=${r}.${n}.${i}${A} <${r}.${n}.${+i + 1}-0` + : `>=${r}.${n}.${i}${A} <${r}.${+n + 1}.0-0` + : `>=${r}.${n}.${i} <${+r + 1}.0.0-0`)), + o('caret return', a), + a + ); + }); + }, + E = (e, t) => ( + o('replaceXRanges', e, t), + e + .split(/\s+/) + .map((e) => B(e, t)) + .join(' ') + ), + B = (e, t) => { + e = e.trim(); + const r = t.loose ? s[a.XRANGELOOSE] : s[a.XRANGE]; + return e.replace(r, (r, A, n, i, s, a) => { + o('xRange', e, r, A, n, i, s, a); + const c = p(n), + g = c || p(i), + l = g || p(s), + u = l; + return ( + '=' === A && u && (A = ''), + (a = t.includePrerelease ? '-0' : ''), + c + ? (r = '>' === A || '<' === A ? '<0.0.0-0' : '*') + : A && u + ? (g && (i = 0), + (s = 0), + '>' === A + ? ((A = '>='), + g + ? ((n = +n + 1), (i = 0), (s = 0)) + : ((i = +i + 1), (s = 0))) + : '<=' === A && + ((A = '<'), g ? (n = +n + 1) : (i = +i + 1)), + '<' === A && (a = '-0'), + (r = `${A + n}.${i}.${s}${a}`)) + : g + ? (r = `>=${n}.0.0${a} <${+n + 1}.0.0-0`) + : l && (r = `>=${n}.${i}.0${a} <${n}.${+i + 1}.0-0`), + o('xRange return', r), + r + ); + }); + }, + y = (e, t) => ( + o('replaceStars', e, t), e.trim().replace(s[a.STAR], '') + ), + m = (e, t) => ( + o('replaceGTE0', e, t), + e.trim().replace(s[t.includePrerelease ? a.GTE0PRE : a.GTE0], '') + ), + w = (e) => (t, r, A, n, o, i, s, a, c, g, l, u, h) => + `${(r = p(A) + ? '' + : p(n) + ? `>=${A}.0.0${e ? '-0' : ''}` + : p(o) + ? `>=${A}.${n}.0${e ? '-0' : ''}` + : i + ? '>=' + r + : `>=${r}${e ? '-0' : ''}`)} ${(a = p(c) + ? '' + : p(g) + ? `<${+c + 1}.0.0-0` + : p(l) + ? `<${c}.${+g + 1}.0-0` + : u + ? `<=${c}.${g}.${l}-${u}` + : e + ? `<${c}.${g}.${+l + 1}-0` + : '<=' + a)}`.trim(), + Q = (e, t, r) => { + for (let r = 0; r < e.length; r++) if (!e[r].test(t)) return !1; + if (t.prerelease.length && !r.includePrerelease) { + for (let r = 0; r < e.length; r++) + if ( + (o(e[r].semver), + e[r].semver !== n.ANY && e[r].semver.prerelease.length > 0) + ) { + const A = e[r].semver; + if ( + A.major === t.major && + A.minor === t.minor && + A.patch === t.patch + ) + return !0; + } + return !1; + } + return !0; + }; + }, + 14772: (e, t, r) => { + const A = r(6029), + { MAX_LENGTH: n, MAX_SAFE_INTEGER: o } = r(76483), + { re: i, t: s } = r(49439), + { compareIdentifiers: a } = r(99297); + class c { + constructor(e, t) { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof c) + ) { + if ( + e.loose === !!t.loose && + e.includePrerelease === !!t.includePrerelease + ) + return e; + e = e.version; + } else if ('string' != typeof e) + throw new TypeError('Invalid Version: ' + e); + if (e.length > n) + throw new TypeError(`version is longer than ${n} characters`); + A('SemVer', e, t), + (this.options = t), + (this.loose = !!t.loose), + (this.includePrerelease = !!t.includePrerelease); + const r = e.trim().match(t.loose ? i[s.LOOSE] : i[s.FULL]); + if (!r) throw new TypeError('Invalid Version: ' + e); + if ( + ((this.raw = e), + (this.major = +r[1]), + (this.minor = +r[2]), + (this.patch = +r[3]), + this.major > o || this.major < 0) + ) + throw new TypeError('Invalid major version'); + if (this.minor > o || this.minor < 0) + throw new TypeError('Invalid minor version'); + if (this.patch > o || this.patch < 0) + throw new TypeError('Invalid patch version'); + r[4] + ? (this.prerelease = r[4].split('.').map((e) => { + if (/^[0-9]+$/.test(e)) { + const t = +e; + if (t >= 0 && t < o) return t; + } + return e; + })) + : (this.prerelease = []), + (this.build = r[5] ? r[5].split('.') : []), + this.format(); + } + format() { + return ( + (this.version = `${this.major}.${this.minor}.${this.patch}`), + this.prerelease.length && + (this.version += '-' + this.prerelease.join('.')), + this.version + ); + } + toString() { + return this.version; + } + compare(e) { + if ( + (A('SemVer.compare', this.version, this.options, e), + !(e instanceof c)) + ) { + if ('string' == typeof e && e === this.version) return 0; + e = new c(e, this.options); + } + return e.version === this.version + ? 0 + : this.compareMain(e) || this.comparePre(e); + } + compareMain(e) { + return ( + e instanceof c || (e = new c(e, this.options)), + a(this.major, e.major) || + a(this.minor, e.minor) || + a(this.patch, e.patch) + ); + } + comparePre(e) { + if ( + (e instanceof c || (e = new c(e, this.options)), + this.prerelease.length && !e.prerelease.length) + ) + return -1; + if (!this.prerelease.length && e.prerelease.length) return 1; + if (!this.prerelease.length && !e.prerelease.length) return 0; + let t = 0; + do { + const r = this.prerelease[t], + n = e.prerelease[t]; + if ( + (A('prerelease compare', t, r, n), void 0 === r && void 0 === n) + ) + return 0; + if (void 0 === n) return 1; + if (void 0 === r) return -1; + if (r !== n) return a(r, n); + } while (++t); + } + compareBuild(e) { + e instanceof c || (e = new c(e, this.options)); + let t = 0; + do { + const r = this.build[t], + n = e.build[t]; + if ( + (A('prerelease compare', t, r, n), void 0 === r && void 0 === n) + ) + return 0; + if (void 0 === n) return 1; + if (void 0 === r) return -1; + if (r !== n) return a(r, n); + } while (++t); + } + inc(e, t) { + switch (e) { + case 'premajor': + (this.prerelease.length = 0), + (this.patch = 0), + (this.minor = 0), + this.major++, + this.inc('pre', t); + break; + case 'preminor': + (this.prerelease.length = 0), + (this.patch = 0), + this.minor++, + this.inc('pre', t); + break; + case 'prepatch': + (this.prerelease.length = 0), + this.inc('patch', t), + this.inc('pre', t); + break; + case 'prerelease': + 0 === this.prerelease.length && this.inc('patch', t), + this.inc('pre', t); + break; + case 'major': + (0 === this.minor && + 0 === this.patch && + 0 !== this.prerelease.length) || + this.major++, + (this.minor = 0), + (this.patch = 0), + (this.prerelease = []); + break; + case 'minor': + (0 === this.patch && 0 !== this.prerelease.length) || + this.minor++, + (this.patch = 0), + (this.prerelease = []); + break; + case 'patch': + 0 === this.prerelease.length && this.patch++, + (this.prerelease = []); + break; + case 'pre': + if (0 === this.prerelease.length) this.prerelease = [0]; + else { + let e = this.prerelease.length; + for (; --e >= 0; ) + 'number' == typeof this.prerelease[e] && + (this.prerelease[e]++, (e = -2)); + -1 === e && this.prerelease.push(0); + } + t && + (this.prerelease[0] === t + ? isNaN(this.prerelease[1]) && (this.prerelease = [t, 0]) + : (this.prerelease = [t, 0])); + break; + default: + throw new Error('invalid increment argument: ' + e); + } + return this.format(), (this.raw = this.version), this; + } + } + e.exports = c; + }, + 31192: (e, t, r) => { + const A = r(21883); + e.exports = (e, t) => { + const r = A(e.trim().replace(/^[=v]+/, ''), t); + return r ? r.version : null; + }; + }, + 38754: (e, t, r) => { + const A = r(78760), + n = r(83286), + o = r(26544), + i = r(44984), + s = r(65069), + a = r(93845); + e.exports = (e, t, r, c) => { + switch (t) { + case '===': + return ( + 'object' == typeof e && (e = e.version), + 'object' == typeof r && (r = r.version), + e === r + ); + case '!==': + return ( + 'object' == typeof e && (e = e.version), + 'object' == typeof r && (r = r.version), + e !== r + ); + case '': + case '=': + case '==': + return A(e, r, c); + case '!=': + return n(e, r, c); + case '>': + return o(e, r, c); + case '>=': + return i(e, r, c); + case '<': + return s(e, r, c); + case '<=': + return a(e, r, c); + default: + throw new TypeError('Invalid operator: ' + t); + } + }; + }, + 38113: (e, t, r) => { + const A = r(14772), + n = r(21883), + { re: o, t: i } = r(49439); + e.exports = (e, t) => { + if (e instanceof A) return e; + if (('number' == typeof e && (e = String(e)), 'string' != typeof e)) + return null; + let r = null; + if ((t = t || {}).rtl) { + let t; + for ( + ; + (t = o[i.COERCERTL].exec(e)) && + (!r || r.index + r[0].length !== e.length); + + ) + (r && t.index + t[0].length === r.index + r[0].length) || (r = t), + (o[i.COERCERTL].lastIndex = + t.index + t[1].length + t[2].length); + o[i.COERCERTL].lastIndex = -1; + } else r = e.match(o[i.COERCE]); + return null === r + ? null + : n(`${r[2]}.${r[3] || '0'}.${r[4] || '0'}`, t); + }; + }, + 63353: (e, t, r) => { + const A = r(14772); + e.exports = (e, t, r) => { + const n = new A(e, r), + o = new A(t, r); + return n.compare(o) || n.compareBuild(o); + }; + }, + 58566: (e, t, r) => { + const A = r(17340); + e.exports = (e, t) => A(e, t, !0); + }, + 17340: (e, t, r) => { + const A = r(14772); + e.exports = (e, t, r) => new A(e, r).compare(new A(t, r)); + }, + 29301: (e, t, r) => { + const A = r(21883), + n = r(78760); + e.exports = (e, t) => { + if (n(e, t)) return null; + { + const r = A(e), + n = A(t), + o = r.prerelease.length || n.prerelease.length, + i = o ? 'pre' : '', + s = o ? 'prerelease' : ''; + for (const e in r) + if ( + ('major' === e || 'minor' === e || 'patch' === e) && + r[e] !== n[e] + ) + return i + e; + return s; + } + }; + }, + 78760: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => 0 === A(e, t, r); + }, + 26544: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => A(e, t, r) > 0; + }, + 44984: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => A(e, t, r) >= 0; + }, + 24063: (e, t, r) => { + const A = r(14772); + e.exports = (e, t, r, n) => { + 'string' == typeof r && ((n = r), (r = void 0)); + try { + return new A(e, r).inc(t, n).version; + } catch (e) { + return null; + } + }; + }, + 65069: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => A(e, t, r) < 0; + }, + 93845: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => A(e, t, r) <= 0; + }, + 75157: (e, t, r) => { + const A = r(14772); + e.exports = (e, t) => new A(e, t).major; + }, + 5195: (e, t, r) => { + const A = r(14772); + e.exports = (e, t) => new A(e, t).minor; + }, + 83286: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => 0 !== A(e, t, r); + }, + 21883: (e, t, r) => { + const { MAX_LENGTH: A } = r(76483), + { re: n, t: o } = r(49439), + i = r(14772); + e.exports = (e, t) => { + if ( + ((t && 'object' == typeof t) || + (t = { loose: !!t, includePrerelease: !1 }), + e instanceof i) + ) + return e; + if ('string' != typeof e) return null; + if (e.length > A) return null; + if (!(t.loose ? n[o.LOOSE] : n[o.FULL]).test(e)) return null; + try { + return new i(e, t); + } catch (e) { + return null; + } + }; + }, + 39592: (e, t, r) => { + const A = r(14772); + e.exports = (e, t) => new A(e, t).patch; + }, + 27050: (e, t, r) => { + const A = r(21883); + e.exports = (e, t) => { + const r = A(e, t); + return r && r.prerelease.length ? r.prerelease : null; + }; + }, + 93788: (e, t, r) => { + const A = r(17340); + e.exports = (e, t, r) => A(t, e, r); + }, + 15213: (e, t, r) => { + const A = r(63353); + e.exports = (e, t) => e.sort((e, r) => A(r, e, t)); + }, + 73011: (e, t, r) => { + const A = r(73004); + e.exports = (e, t, r) => { + try { + t = new A(t, r); + } catch (e) { + return !1; + } + return t.test(e); + }; + }, + 71102: (e, t, r) => { + const A = r(63353); + e.exports = (e, t) => e.sort((e, r) => A(e, r, t)); + }, + 99589: (e, t, r) => { + const A = r(21883); + e.exports = (e, t) => { + const r = A(e, t); + return r ? r.version : null; + }; + }, + 53887: (e, t, r) => { + const A = r(49439); + e.exports = { + re: A.re, + src: A.src, + tokens: A.t, + SEMVER_SPEC_VERSION: r(76483).SEMVER_SPEC_VERSION, + SemVer: r(14772), + compareIdentifiers: r(99297).compareIdentifiers, + rcompareIdentifiers: r(99297).rcompareIdentifiers, + parse: r(21883), + valid: r(99589), + clean: r(31192), + inc: r(24063), + diff: r(29301), + major: r(75157), + minor: r(5195), + patch: r(39592), + prerelease: r(27050), + compare: r(17340), + rcompare: r(93788), + compareLoose: r(58566), + compareBuild: r(63353), + sort: r(71102), + rsort: r(15213), + gt: r(26544), + lt: r(65069), + eq: r(78760), + neq: r(83286), + gte: r(44984), + lte: r(93845), + cmp: r(38754), + coerce: r(38113), + Comparator: r(29069), + Range: r(73004), + satisfies: r(73011), + toComparators: r(47753), + maxSatisfying: r(1895), + minSatisfying: r(33252), + minVersion: r(4224), + validRange: r(44315), + outside: r(842), + gtr: r(69258), + ltr: r(36928), + intersects: r(87395), + simplifyRange: r(3530), + subset: r(74264), + }; + }, + 76483: (e) => { + const t = Number.MAX_SAFE_INTEGER || 9007199254740991; + e.exports = { + SEMVER_SPEC_VERSION: '2.0.0', + MAX_LENGTH: 256, + MAX_SAFE_INTEGER: t, + MAX_SAFE_COMPONENT_LENGTH: 16, + }; + }, + 6029: (e) => { + const t = + 'object' == typeof process && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) + ? (...e) => console.error('SEMVER', ...e) + : () => {}; + e.exports = t; + }, + 99297: (e) => { + const t = /^[0-9]+$/, + r = (e, r) => { + const A = t.test(e), + n = t.test(r); + return ( + A && n && ((e = +e), (r = +r)), + e === r ? 0 : A && !n ? -1 : n && !A ? 1 : e < r ? -1 : 1 + ); + }; + e.exports = { + compareIdentifiers: r, + rcompareIdentifiers: (e, t) => r(t, e), + }; + }, + 49439: (e, t, r) => { + const { MAX_SAFE_COMPONENT_LENGTH: A } = r(76483), + n = r(6029), + o = ((t = e.exports = {}).re = []), + i = (t.src = []), + s = (t.t = {}); + let a = 0; + const c = (e, t, r) => { + const A = a++; + n(A, t), + (s[e] = A), + (i[A] = t), + (o[A] = new RegExp(t, r ? 'g' : void 0)); + }; + c('NUMERICIDENTIFIER', '0|[1-9]\\d*'), + c('NUMERICIDENTIFIERLOOSE', '[0-9]+'), + c('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*'), + c( + 'MAINVERSION', + `(${i[s.NUMERICIDENTIFIER]})\\.(${i[s.NUMERICIDENTIFIER]})\\.(${ + i[s.NUMERICIDENTIFIER] + })` + ), + c( + 'MAINVERSIONLOOSE', + `(${i[s.NUMERICIDENTIFIERLOOSE]})\\.(${ + i[s.NUMERICIDENTIFIERLOOSE] + })\\.(${i[s.NUMERICIDENTIFIERLOOSE]})` + ), + c( + 'PRERELEASEIDENTIFIER', + `(?:${i[s.NUMERICIDENTIFIER]}|${i[s.NONNUMERICIDENTIFIER]})` + ), + c( + 'PRERELEASEIDENTIFIERLOOSE', + `(?:${i[s.NUMERICIDENTIFIERLOOSE]}|${i[s.NONNUMERICIDENTIFIER]})` + ), + c( + 'PRERELEASE', + `(?:-(${i[s.PRERELEASEIDENTIFIER]}(?:\\.${ + i[s.PRERELEASEIDENTIFIER] + })*))` + ), + c( + 'PRERELEASELOOSE', + `(?:-?(${i[s.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${ + i[s.PRERELEASEIDENTIFIERLOOSE] + })*))` + ), + c('BUILDIDENTIFIER', '[0-9A-Za-z-]+'), + c( + 'BUILD', + `(?:\\+(${i[s.BUILDIDENTIFIER]}(?:\\.${i[s.BUILDIDENTIFIER]})*))` + ), + c( + 'FULLPLAIN', + `v?${i[s.MAINVERSION]}${i[s.PRERELEASE]}?${i[s.BUILD]}?` + ), + c('FULL', `^${i[s.FULLPLAIN]}$`), + c( + 'LOOSEPLAIN', + `[v=\\s]*${i[s.MAINVERSIONLOOSE]}${i[s.PRERELEASELOOSE]}?${ + i[s.BUILD] + }?` + ), + c('LOOSE', `^${i[s.LOOSEPLAIN]}$`), + c('GTLT', '((?:<|>)?=?)'), + c('XRANGEIDENTIFIERLOOSE', i[s.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'), + c('XRANGEIDENTIFIER', i[s.NUMERICIDENTIFIER] + '|x|X|\\*'), + c( + 'XRANGEPLAIN', + `[v=\\s]*(${i[s.XRANGEIDENTIFIER]})(?:\\.(${ + i[s.XRANGEIDENTIFIER] + })(?:\\.(${i[s.XRANGEIDENTIFIER]})(?:${i[s.PRERELEASE]})?${ + i[s.BUILD] + }?)?)?` + ), + c( + 'XRANGEPLAINLOOSE', + `[v=\\s]*(${i[s.XRANGEIDENTIFIERLOOSE]})(?:\\.(${ + i[s.XRANGEIDENTIFIERLOOSE] + })(?:\\.(${i[s.XRANGEIDENTIFIERLOOSE]})(?:${ + i[s.PRERELEASELOOSE] + })?${i[s.BUILD]}?)?)?` + ), + c('XRANGE', `^${i[s.GTLT]}\\s*${i[s.XRANGEPLAIN]}$`), + c('XRANGELOOSE', `^${i[s.GTLT]}\\s*${i[s.XRANGEPLAINLOOSE]}$`), + c( + 'COERCE', + `(^|[^\\d])(\\d{1,${A}})(?:\\.(\\d{1,${A}}))?(?:\\.(\\d{1,${A}}))?(?:$|[^\\d])` + ), + c('COERCERTL', i[s.COERCE], !0), + c('LONETILDE', '(?:~>?)'), + c('TILDETRIM', `(\\s*)${i[s.LONETILDE]}\\s+`, !0), + (t.tildeTrimReplace = '$1~'), + c('TILDE', `^${i[s.LONETILDE]}${i[s.XRANGEPLAIN]}$`), + c('TILDELOOSE', `^${i[s.LONETILDE]}${i[s.XRANGEPLAINLOOSE]}$`), + c('LONECARET', '(?:\\^)'), + c('CARETTRIM', `(\\s*)${i[s.LONECARET]}\\s+`, !0), + (t.caretTrimReplace = '$1^'), + c('CARET', `^${i[s.LONECARET]}${i[s.XRANGEPLAIN]}$`), + c('CARETLOOSE', `^${i[s.LONECARET]}${i[s.XRANGEPLAINLOOSE]}$`), + c('COMPARATORLOOSE', `^${i[s.GTLT]}\\s*(${i[s.LOOSEPLAIN]})$|^$`), + c('COMPARATOR', `^${i[s.GTLT]}\\s*(${i[s.FULLPLAIN]})$|^$`), + c( + 'COMPARATORTRIM', + `(\\s*)${i[s.GTLT]}\\s*(${i[s.LOOSEPLAIN]}|${i[s.XRANGEPLAIN]})`, + !0 + ), + (t.comparatorTrimReplace = '$1$2$3'), + c( + 'HYPHENRANGE', + `^\\s*(${i[s.XRANGEPLAIN]})\\s+-\\s+(${i[s.XRANGEPLAIN]})\\s*$` + ), + c( + 'HYPHENRANGELOOSE', + `^\\s*(${i[s.XRANGEPLAINLOOSE]})\\s+-\\s+(${ + i[s.XRANGEPLAINLOOSE] + })\\s*$` + ), + c('STAR', '(<|>)?=?\\s*\\*'), + c('GTE0', '^\\s*>=\\s*0.0.0\\s*$'), + c('GTE0PRE', '^\\s*>=\\s*0.0.0-0\\s*$'); + }, + 69258: (e, t, r) => { + const A = r(842); + e.exports = (e, t, r) => A(e, t, '>', r); + }, + 87395: (e, t, r) => { + const A = r(73004); + e.exports = (e, t, r) => ( + (e = new A(e, r)), (t = new A(t, r)), e.intersects(t) + ); + }, + 36928: (e, t, r) => { + const A = r(842); + e.exports = (e, t, r) => A(e, t, '<', r); + }, + 1895: (e, t, r) => { + const A = r(14772), + n = r(73004); + e.exports = (e, t, r) => { + let o = null, + i = null, + s = null; + try { + s = new n(t, r); + } catch (e) { + return null; + } + return ( + e.forEach((e) => { + s.test(e) && + ((o && -1 !== i.compare(e)) || ((o = e), (i = new A(o, r)))); + }), + o + ); + }; + }, + 33252: (e, t, r) => { + const A = r(14772), + n = r(73004); + e.exports = (e, t, r) => { + let o = null, + i = null, + s = null; + try { + s = new n(t, r); + } catch (e) { + return null; + } + return ( + e.forEach((e) => { + s.test(e) && + ((o && 1 !== i.compare(e)) || ((o = e), (i = new A(o, r)))); + }), + o + ); + }; + }, + 4224: (e, t, r) => { + const A = r(14772), + n = r(73004), + o = r(26544); + e.exports = (e, t) => { + e = new n(e, t); + let r = new A('0.0.0'); + if (e.test(r)) return r; + if (((r = new A('0.0.0-0')), e.test(r))) return r; + r = null; + for (let t = 0; t < e.set.length; ++t) { + e.set[t].forEach((e) => { + const t = new A(e.semver.version); + switch (e.operator) { + case '>': + 0 === t.prerelease.length ? t.patch++ : t.prerelease.push(0), + (t.raw = t.format()); + case '': + case '>=': + (r && !o(r, t)) || (r = t); + break; + case '<': + case '<=': + break; + default: + throw new Error('Unexpected operation: ' + e.operator); + } + }); + } + return r && e.test(r) ? r : null; + }; + }, + 842: (e, t, r) => { + const A = r(14772), + n = r(29069), + { ANY: o } = n, + i = r(73004), + s = r(73011), + a = r(26544), + c = r(65069), + g = r(93845), + l = r(44984); + e.exports = (e, t, r, u) => { + let h, p, d, C, f; + switch (((e = new A(e, u)), (t = new i(t, u)), r)) { + case '>': + (h = a), (p = g), (d = c), (C = '>'), (f = '>='); + break; + case '<': + (h = c), (p = l), (d = a), (C = '<'), (f = '<='); + break; + default: + throw new TypeError('Must provide a hilo val of "<" or ">"'); + } + if (s(e, t, u)) return !1; + for (let r = 0; r < t.set.length; ++r) { + const A = t.set[r]; + let i = null, + s = null; + if ( + (A.forEach((e) => { + e.semver === o && (e = new n('>=0.0.0')), + (i = i || e), + (s = s || e), + h(e.semver, i.semver, u) + ? (i = e) + : d(e.semver, s.semver, u) && (s = e); + }), + i.operator === C || i.operator === f) + ) + return !1; + if ((!s.operator || s.operator === C) && p(e, s.semver)) return !1; + if (s.operator === f && d(e, s.semver)) return !1; + } + return !0; + }; + }, + 3530: (e, t, r) => { + const A = r(73011), + n = r(17340); + e.exports = (e, t, r) => { + const o = []; + let i = null, + s = null; + const a = e.sort((e, t) => n(e, t, r)); + for (const e of a) { + A(e, t, r) + ? ((s = e), i || (i = e)) + : (s && o.push([i, s]), (s = null), (i = null)); + } + i && o.push([i, null]); + const c = []; + for (const [e, t] of o) + e === t + ? c.push(e) + : t || e !== a[0] + ? t + ? e === a[0] + ? c.push('<=' + t) + : c.push(`${e} - ${t}`) + : c.push('>=' + e) + : c.push('*'); + const g = c.join(' || '), + l = 'string' == typeof t.raw ? t.raw : String(t); + return g.length < l.length ? g : t; + }; + }, + 74264: (e, t, r) => { + const A = r(73004), + { ANY: n } = r(29069), + o = r(73011), + i = r(17340), + s = (e, t, r) => { + if (1 === e.length && e[0].semver === n) + return 1 === t.length && t[0].semver === n; + const A = new Set(); + let s, g, l, u, h, p, d; + for (const t of e) + '>' === t.operator || '>=' === t.operator + ? (s = a(s, t, r)) + : '<' === t.operator || '<=' === t.operator + ? (g = c(g, t, r)) + : A.add(t.semver); + if (A.size > 1) return null; + if (s && g) { + if (((l = i(s.semver, g.semver, r)), l > 0)) return null; + if (0 === l && ('>=' !== s.operator || '<=' !== g.operator)) + return null; + } + for (const e of A) { + if (s && !o(e, String(s), r)) return null; + if (g && !o(e, String(g), r)) return null; + for (const A of t) if (!o(e, String(A), r)) return !1; + return !0; + } + for (const e of t) { + if ( + ((d = d || '>' === e.operator || '>=' === e.operator), + (p = p || '<' === e.operator || '<=' === e.operator), + s) + ) + if ('>' === e.operator || '>=' === e.operator) { + if (((u = a(s, e, r)), u === e)) return !1; + } else if ('>=' === s.operator && !o(s.semver, String(e), r)) + return !1; + if (g) + if ('<' === e.operator || '<=' === e.operator) { + if (((h = c(g, e, r)), h === e)) return !1; + } else if ('<=' === g.operator && !o(g.semver, String(e), r)) + return !1; + if (!e.operator && (g || s) && 0 !== l) return !1; + } + return !(s && p && !g && 0 !== l) && !(g && d && !s && 0 !== l); + }, + a = (e, t, r) => { + if (!e) return t; + const A = i(e.semver, t.semver, r); + return A > 0 + ? e + : A < 0 || ('>' === t.operator && '>=' === e.operator) + ? t + : e; + }, + c = (e, t, r) => { + if (!e) return t; + const A = i(e.semver, t.semver, r); + return A < 0 + ? e + : A > 0 || ('<' === t.operator && '<=' === e.operator) + ? t + : e; + }; + e.exports = (e, t, r) => { + (e = new A(e, r)), (t = new A(t, r)); + let n = !1; + e: for (const A of e.set) { + for (const e of t.set) { + const t = s(A, e, r); + if (((n = n || null !== t), t)) continue e; + } + if (n) return !1; + } + return !0; + }; + }, + 47753: (e, t, r) => { + const A = r(73004); + e.exports = (e, t) => + new A(e, t).set.map((e) => + e + .map((e) => e.value) + .join(' ') + .trim() + .split(' ') + ); + }, + 44315: (e, t, r) => { + const A = r(73004); + e.exports = (e, t) => { + try { + return new A(e, t).range || '*'; + } catch (e) { + return null; + } + }; + }, + 91470: (e, t, r) => { + 'use strict'; + const A = r(67719); + e.exports = (e = '') => { + const t = e.match(A); + if (!t) return null; + const [r, n] = t[0].replace(/#! ?/, '').split(' '), + o = r.split('/').pop(); + return 'env' === o ? n : n ? `${o} ${n}` : o; + }; + }, + 67719: (e) => { + 'use strict'; + e.exports = /^#!(.*)/; + }, + 17234: (e) => { + 'use strict'; + e.exports = (e) => { + const t = /^\\\\\?\\/.test(e), + r = /[^\u0000-\u0080]+/.test(e); + return t || r ? e : e.replace(/\\/g, '/'); + }; + }, + 10129: (e, t, r) => { + 'use strict'; + const A = r(76417), + n = r(19184), + o = r(92413).Transform, + i = ['sha256', 'sha384', 'sha512'], + s = /^[a-z0-9+/]+(?:=?=?)$/i, + a = /^([^-]+)-([^?]+)([?\S*]*)$/, + c = /^([^-]+)-([A-Za-z0-9+/=]{44,88})(\?[\x21-\x7E]*)*$/, + g = /^[\x21-\x7E]+$/, + l = n({ + algorithms: { default: ['sha512'] }, + error: { default: !1 }, + integrity: {}, + options: { default: [] }, + pickAlgorithm: { default: () => B }, + Promise: { default: () => Promise }, + sep: { default: ' ' }, + single: { default: !1 }, + size: {}, + strict: { default: !1 }, + }); + class u { + get isHash() { + return !0; + } + constructor(e, t) { + const r = !!(t = l(t)).strict; + this.source = e.trim(); + const A = this.source.match(r ? c : a); + if (!A) return; + if (r && !i.some((e) => e === A[1])) return; + (this.algorithm = A[1]), (this.digest = A[2]); + const n = A[3]; + this.options = n ? n.slice(1).split('?') : []; + } + hexDigest() { + return ( + this.digest && Buffer.from(this.digest, 'base64').toString('hex') + ); + } + toJSON() { + return this.toString(); + } + toString(e) { + if ( + (e = l(e)).strict && + !( + i.some((e) => e === this.algorithm) && + this.digest.match(s) && + (this.options || []).every((e) => e.match(g)) + ) + ) + return ''; + const t = + this.options && this.options.length + ? '?' + this.options.join('?') + : ''; + return `${this.algorithm}-${this.digest}${t}`; + } + } + class h { + get isIntegrity() { + return !0; + } + toJSON() { + return this.toString(); + } + toString(e) { + let t = (e = l(e)).sep || ' '; + return ( + e.strict && (t = t.replace(/\S+/g, ' ')), + Object.keys(this) + .map((r) => + this[r] + .map((t) => u.prototype.toString.call(t, e)) + .filter((e) => e.length) + .join(t) + ) + .filter((e) => e.length) + .join(t) + ); + } + concat(e, t) { + t = l(t); + const r = 'string' == typeof e ? e : C(e, t); + return p(`${this.toString(t)} ${r}`, t); + } + hexDigest() { + return p(this, { single: !0 }).hexDigest(); + } + match(e, t) { + const r = p(e, (t = l(t))), + A = r.pickAlgorithm(t); + return ( + (this[A] && + r[A] && + this[A].find((e) => r[A].find((t) => e.digest === t.digest))) || + !1 + ); + } + pickAlgorithm(e) { + const t = (e = l(e)).pickAlgorithm, + r = Object.keys(this); + if (!r.length) + throw new Error( + 'No algorithms available for ' + JSON.stringify(this.toString()) + ); + return r.reduce((e, r) => t(e, r) || e); + } + } + function p(e, t) { + if (((t = l(t)), 'string' == typeof e)) return d(e, t); + if (e.algorithm && e.digest) { + const r = new h(); + return (r[e.algorithm] = [e]), d(C(r, t), t); + } + return d(C(e, t), t); + } + function d(e, t) { + return t.single + ? new u(e, t) + : e + .trim() + .split(/\s+/) + .reduce((e, r) => { + const A = new u(r, t); + if (A.algorithm && A.digest) { + const t = A.algorithm; + e[t] || (e[t] = []), e[t].push(A); + } + return e; + }, new h()); + } + function C(e, t) { + return ( + (t = l(t)), + e.algorithm && e.digest + ? u.prototype.toString.call(e, t) + : 'string' == typeof e + ? C(p(e, t), t) + : h.prototype.toString.call(e, t) + ); + } + function f(e) { + const t = (e = l(e)).integrity && p(e.integrity, e), + r = t && Object.keys(t).length, + n = r && t.pickAlgorithm(e), + i = r && t[n], + s = Array.from(new Set(e.algorithms.concat(n ? [n] : []))), + a = s.map(A.createHash); + let c = 0; + const g = new o({ + transform(e, t, r) { + (c += e.length), a.forEach((r) => r.update(e, t)), r(null, e, t); + }, + }).on('end', () => { + const A = + e.options && e.options.length ? '?' + e.options.join('?') : '', + o = p( + a.map((e, t) => `${s[t]}-${e.digest('base64')}${A}`).join(' '), + e + ), + l = r && o.match(t, e); + if ('number' == typeof e.size && c !== e.size) { + const r = new Error( + `stream size mismatch when checking ${t}.\n Wanted: ${e.size}\n Found: ${c}` + ); + (r.code = 'EBADSIZE'), + (r.found = c), + (r.expected = e.size), + (r.sri = t), + g.emit('error', r); + } else if (e.integrity && !l) { + const e = new Error( + `${t} integrity checksum failed when using ${n}: wanted ${i} but got ${o}. (${c} bytes)` + ); + (e.code = 'EINTEGRITY'), + (e.found = o), + (e.expected = i), + (e.algorithm = n), + (e.sri = t), + g.emit('error', e); + } else + g.emit('size', c), + g.emit('integrity', o), + l && g.emit('verified', l); + }); + return g; + } + e.exports.Sd = function (e, t) { + const r = (t = l(t)).algorithms, + n = t.options && t.options.length ? '?' + t.options.join('?') : ''; + return r.reduce((r, o) => { + const i = A.createHash(o).update(e).digest('base64'), + s = new u(`${o}-${i}${n}`, t); + if (s.algorithm && s.digest) { + const e = s.algorithm; + r[e] || (r[e] = []), r[e].push(s); + } + return r; + }, new h()); + }; + const I = new Set(A.getHashes()), + E = [ + 'md5', + 'whirlpool', + 'sha1', + 'sha224', + 'sha256', + 'sha384', + 'sha512', + 'sha3', + 'sha3-256', + 'sha3-384', + 'sha3-512', + 'sha3_256', + 'sha3_384', + 'sha3_512', + ].filter((e) => I.has(e)); + function B(e, t) { + return E.indexOf(e.toLowerCase()) >= E.indexOf(t.toLowerCase()) + ? e + : t; + } + }, + 69538: (e, t, r) => { + 'use strict'; + var A = r(13499).Buffer, + n = + A.isEncoding || + function (e) { + switch ((e = '' + e) && e.toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + case 'raw': + return !0; + default: + return !1; + } + }; + function o(e) { + var t; + switch ( + ((this.encoding = (function (e) { + var t = (function (e) { + if (!e) return 'utf8'; + for (var t; ; ) + switch (e) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return e; + default: + if (t) return; + (e = ('' + e).toLowerCase()), (t = !0); + } + })(e); + if ('string' != typeof t && (A.isEncoding === n || !n(e))) + throw new Error('Unknown encoding: ' + e); + return t || e; + })(e)), + this.encoding) + ) { + case 'utf16le': + (this.text = a), (this.end = c), (t = 4); + break; + case 'utf8': + (this.fillLast = s), (t = 4); + break; + case 'base64': + (this.text = g), (this.end = l), (t = 3); + break; + default: + return (this.write = u), void (this.end = h); + } + (this.lastNeed = 0), + (this.lastTotal = 0), + (this.lastChar = A.allocUnsafe(t)); + } + function i(e) { + return e <= 127 + ? 0 + : e >> 5 == 6 + ? 2 + : e >> 4 == 14 + ? 3 + : e >> 3 == 30 + ? 4 + : e >> 6 == 2 + ? -1 + : -2; + } + function s(e) { + var t = this.lastTotal - this.lastNeed, + r = (function (e, t, r) { + if (128 != (192 & t[0])) return (e.lastNeed = 0), '�'; + if (e.lastNeed > 1 && t.length > 1) { + if (128 != (192 & t[1])) return (e.lastNeed = 1), '�'; + if (e.lastNeed > 2 && t.length > 2 && 128 != (192 & t[2])) + return (e.lastNeed = 2), '�'; + } + })(this, e); + return void 0 !== r + ? r + : this.lastNeed <= e.length + ? (e.copy(this.lastChar, t, 0, this.lastNeed), + this.lastChar.toString(this.encoding, 0, this.lastTotal)) + : (e.copy(this.lastChar, t, 0, e.length), + void (this.lastNeed -= e.length)); + } + function a(e, t) { + if ((e.length - t) % 2 == 0) { + var r = e.toString('utf16le', t); + if (r) { + var A = r.charCodeAt(r.length - 1); + if (A >= 55296 && A <= 56319) + return ( + (this.lastNeed = 2), + (this.lastTotal = 4), + (this.lastChar[0] = e[e.length - 2]), + (this.lastChar[1] = e[e.length - 1]), + r.slice(0, -1) + ); + } + return r; + } + return ( + (this.lastNeed = 1), + (this.lastTotal = 2), + (this.lastChar[0] = e[e.length - 1]), + e.toString('utf16le', t, e.length - 1) + ); + } + function c(e) { + var t = e && e.length ? this.write(e) : ''; + if (this.lastNeed) { + var r = this.lastTotal - this.lastNeed; + return t + this.lastChar.toString('utf16le', 0, r); + } + return t; + } + function g(e, t) { + var r = (e.length - t) % 3; + return 0 === r + ? e.toString('base64', t) + : ((this.lastNeed = 3 - r), + (this.lastTotal = 3), + 1 === r + ? (this.lastChar[0] = e[e.length - 1]) + : ((this.lastChar[0] = e[e.length - 2]), + (this.lastChar[1] = e[e.length - 1])), + e.toString('base64', t, e.length - r)); + } + function l(e) { + var t = e && e.length ? this.write(e) : ''; + return this.lastNeed + ? t + this.lastChar.toString('base64', 0, 3 - this.lastNeed) + : t; + } + function u(e) { + return e.toString(this.encoding); + } + function h(e) { + return e && e.length ? this.write(e) : ''; + } + (t.s = o), + (o.prototype.write = function (e) { + if (0 === e.length) return ''; + var t, r; + if (this.lastNeed) { + if (void 0 === (t = this.fillLast(e))) return ''; + (r = this.lastNeed), (this.lastNeed = 0); + } else r = 0; + return r < e.length + ? t + ? t + this.text(e, r) + : this.text(e, r) + : t || ''; + }), + (o.prototype.end = function (e) { + var t = e && e.length ? this.write(e) : ''; + return this.lastNeed ? t + '�' : t; + }), + (o.prototype.text = function (e, t) { + var r = (function (e, t, r) { + var A = t.length - 1; + if (A < r) return 0; + var n = i(t[A]); + if (n >= 0) return n > 0 && (e.lastNeed = n - 1), n; + if (--A < r || -2 === n) return 0; + if ((n = i(t[A])) >= 0) return n > 0 && (e.lastNeed = n - 2), n; + if (--A < r || -2 === n) return 0; + if ((n = i(t[A])) >= 0) + return n > 0 && (2 === n ? (n = 0) : (e.lastNeed = n - 3)), n; + return 0; + })(this, e, t); + if (!this.lastNeed) return e.toString('utf8', t); + this.lastTotal = r; + var A = e.length - (r - this.lastNeed); + return e.copy(this.lastChar, 0, A), e.toString('utf8', t, A); + }), + (o.prototype.fillLast = function (e) { + if (this.lastNeed <= e.length) + return ( + e.copy( + this.lastChar, + this.lastTotal - this.lastNeed, + 0, + this.lastNeed + ), + this.lastChar.toString(this.encoding, 0, this.lastTotal) + ); + e.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, e.length), + (this.lastNeed -= e.length); + }); + }, + 59428: (e, t, r) => { + 'use strict'; + const A = r(12087), + n = r(33867), + o = r(72918), + { env: i } = process; + let s; + function a(e) { + return ( + 0 !== e && { + level: e, + hasBasic: !0, + has256: e >= 2, + has16m: e >= 3, + } + ); + } + function c(e, t) { + if (0 === s) return 0; + if (o('color=16m') || o('color=full') || o('color=truecolor')) + return 3; + if (o('color=256')) return 2; + if (e && !t && void 0 === s) return 0; + const r = s || 0; + if ('dumb' === i.TERM) return r; + if ('win32' === process.platform) { + const e = A.release().split('.'); + return Number(e[0]) >= 10 && Number(e[2]) >= 10586 + ? Number(e[2]) >= 14931 + ? 3 + : 2 + : 1; + } + if ('CI' in i) + return ['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some( + (e) => e in i + ) || 'codeship' === i.CI_NAME + ? 1 + : r; + if ('TEAMCITY_VERSION' in i) + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(i.TEAMCITY_VERSION) + ? 1 + : 0; + if ('GITHUB_ACTIONS' in i) return 1; + if ('truecolor' === i.COLORTERM) return 3; + if ('TERM_PROGRAM' in i) { + const e = parseInt( + (i.TERM_PROGRAM_VERSION || '').split('.')[0], + 10 + ); + switch (i.TERM_PROGRAM) { + case 'iTerm.app': + return e >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + } + } + return /-256(color)?$/i.test(i.TERM) + ? 2 + : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test( + i.TERM + ) || 'COLORTERM' in i + ? 1 + : r; + } + o('no-color') || o('no-colors') || o('color=false') || o('color=never') + ? (s = 0) + : (o('color') || + o('colors') || + o('color=true') || + o('color=always')) && + (s = 1), + 'FORCE_COLOR' in i && + (s = + 'true' === i.FORCE_COLOR + ? 1 + : 'false' === i.FORCE_COLOR + ? 0 + : 0 === i.FORCE_COLOR.length + ? 1 + : Math.min(parseInt(i.FORCE_COLOR, 10), 3)), + (e.exports = { + supportsColor: function (e) { + return a(c(e, e && e.isTTY)); + }, + stdout: a(c(!0, n.isatty(1))), + stderr: a(c(!0, n.isatty(2))), + }); + }, + 93255: (e) => { + 'use strict'; + function t(e) { + return Array.prototype.slice.apply(e); + } + function r(e) { + (this.status = 'pending'), + (this._continuations = []), + (this._parent = null), + (this._paused = !1), + e && + e.call( + this, + this._continueWith.bind(this), + this._failWith.bind(this) + ); + } + function A(e) { + return e && 'function' == typeof e.then; + } + function n(e) { + return e; + } + if ( + ((r.prototype = { + then: function (e, t) { + var n = r.unresolved()._setParent(this); + if (this._isRejected()) { + if (this._paused) + return ( + this._continuations.push({ + promise: n, + nextFn: e, + catchFn: t, + }), + n + ); + if (t) + try { + var o = t(this._error); + return A(o) + ? (this._chainPromiseData(o, n), n) + : r.resolve(o)._setParent(this); + } catch (e) { + return r.reject(e)._setParent(this); + } + return r.reject(this._error)._setParent(this); + } + return ( + this._continuations.push({ promise: n, nextFn: e, catchFn: t }), + this._runResolutions(), + n + ); + }, + catch: function (e) { + if (this._isResolved()) + return r.resolve(this._data)._setParent(this); + var t = r.unresolved()._setParent(this); + return ( + this._continuations.push({ promise: t, catchFn: e }), + this._runRejections(), + t + ); + }, + finally: function (e) { + var t = !1; + function r(r, o) { + if (!t) { + (t = !0), e || (e = n); + var i = e(r); + return A(i) + ? i.then(function () { + if (o) throw o; + return r; + }) + : r; + } + } + return this.then(function (e) { + return r(e); + }).catch(function (e) { + return r(null, e); + }); + }, + pause: function () { + return (this._paused = !0), this; + }, + resume: function () { + var e = this._findFirstPaused(); + return ( + e && + ((e._paused = !1), e._runResolutions(), e._runRejections()), + this + ); + }, + _findAncestry: function () { + return this._continuations.reduce(function (e, t) { + if (t.promise) { + var r = { + promise: t.promise, + children: t.promise._findAncestry(), + }; + e.push(r); + } + return e; + }, []); + }, + _setParent: function (e) { + if (this._parent) throw new Error('parent already set'); + return (this._parent = e), this; + }, + _continueWith: function (e) { + var t = this._findFirstPending(); + t && ((t._data = e), t._setResolved()); + }, + _findFirstPending: function () { + return this._findFirstAncestor(function (e) { + return e._isPending && e._isPending(); + }); + }, + _findFirstPaused: function () { + return this._findFirstAncestor(function (e) { + return e._paused; + }); + }, + _findFirstAncestor: function (e) { + for (var t, r = this; r; ) e(r) && (t = r), (r = r._parent); + return t; + }, + _failWith: function (e) { + var t = this._findFirstPending(); + t && ((t._error = e), t._setRejected()); + }, + _takeContinuations: function () { + return this._continuations.splice(0, this._continuations.length); + }, + _runRejections: function () { + if (!this._paused && this._isRejected()) { + var e = this._error, + t = this._takeContinuations(), + r = this; + t.forEach(function (t) { + if (t.catchFn) + try { + var A = t.catchFn(e); + r._handleUserFunctionResult(A, t.promise); + } catch (e) { + t.promise.reject(e); + } + else t.promise.reject(e); + }); + } + }, + _runResolutions: function () { + if (!this._paused && this._isResolved() && !this._isPending()) { + var e = this._takeContinuations(); + if (A(this._data)) + return this._handleWhenResolvedDataIsPromise(this._data); + var t = this._data, + r = this; + e.forEach(function (e) { + if (e.nextFn) + try { + var A = e.nextFn(t); + r._handleUserFunctionResult(A, e.promise); + } catch (t) { + r._handleResolutionError(t, e); + } + else e.promise && e.promise.resolve(t); + }); + } + }, + _handleResolutionError: function (e, t) { + if ((this._setRejected(), t.catchFn)) + try { + return void t.catchFn(e); + } catch (t) { + e = t; + } + t.promise && t.promise.reject(e); + }, + _handleWhenResolvedDataIsPromise: function (e) { + var t = this; + return e + .then(function (e) { + (t._data = e), t._runResolutions(); + }) + .catch(function (e) { + (t._error = e), t._setRejected(), t._runRejections(); + }); + }, + _handleUserFunctionResult: function (e, t) { + A(e) ? this._chainPromiseData(e, t) : t.resolve(e); + }, + _chainPromiseData: function (e, t) { + e.then(function (e) { + t.resolve(e); + }).catch(function (e) { + t.reject(e); + }); + }, + _setResolved: function () { + (this.status = 'resolved'), + this._paused || this._runResolutions(); + }, + _setRejected: function () { + (this.status = 'rejected'), this._paused || this._runRejections(); + }, + _isPending: function () { + return 'pending' === this.status; + }, + _isResolved: function () { + return 'resolved' === this.status; + }, + _isRejected: function () { + return 'rejected' === this.status; + }, + }), + (r.resolve = function (e) { + return new r(function (t, r) { + A(e) + ? e + .then(function (e) { + t(e); + }) + .catch(function (e) { + r(e); + }) + : t(e); + }); + }), + (r.reject = function (e) { + return new r(function (t, r) { + r(e); + }); + }), + (r.unresolved = function () { + return new r(function (e, t) { + (this.resolve = e), (this.reject = t); + }); + }), + (r.all = function () { + var e = t(arguments); + return ( + Array.isArray(e[0]) && (e = e[0]), + e.length + ? new r(function (t, A) { + var n = [], + o = 0, + i = !1; + e.forEach(function (s, a) { + r.resolve(s) + .then(function (r) { + (n[a] = r), (o += 1) === e.length && t(n); + }) + .catch(function (e) { + !(function (e) { + i || ((i = !0), A(e)); + })(e); + }); + }); + }) + : r.resolve([]) + ); + }), + Promise === r) + ) + throw new Error( + 'Please use SynchronousPromise.installGlobally() to install globally' + ); + var o = Promise; + (r.installGlobally = function (e) { + if (Promise === r) return e; + var A = (function (e) { + if (void 0 === e || e.__patched) return e; + var r = e; + return ( + ((e = function () { + r.apply(this, t(arguments)); + }).__patched = !0), + e + ); + })(e); + return (Promise = r), A; + }), + (r.uninstallGlobally = function () { + Promise === r && (Promise = o); + }), + (e.exports = { SynchronousPromise: r }); + }, + 75799: (e, t, r) => { + var A = r(31669), + n = r(73975), + o = r(77686), + i = r(86897).Writable, + s = r(86897).PassThrough, + a = function () {}, + c = function (e) { + return (e &= 511) && 512 - e; + }, + g = function (e, t) { + (this._parent = e), (this.offset = t), s.call(this); + }; + A.inherits(g, s), + (g.prototype.destroy = function (e) { + this._parent.destroy(e); + }); + var l = function (e) { + if (!(this instanceof l)) return new l(e); + i.call(this, e), + (e = e || {}), + (this._offset = 0), + (this._buffer = n()), + (this._missing = 0), + (this._partial = !1), + (this._onparse = a), + (this._header = null), + (this._stream = null), + (this._overflow = null), + (this._cb = null), + (this._locked = !1), + (this._destroyed = !1), + (this._pax = null), + (this._paxGlobal = null), + (this._gnuLongPath = null), + (this._gnuLongLinkPath = null); + var t = this, + r = t._buffer, + A = function () { + t._continue(); + }, + s = function (e) { + if (((t._locked = !1), e)) return t.destroy(e); + t._stream || A(); + }, + u = function () { + t._stream = null; + var e = c(t._header.size); + e ? t._parse(e, h) : t._parse(512, I), t._locked || A(); + }, + h = function () { + t._buffer.consume(c(t._header.size)), t._parse(512, I), A(); + }, + p = function () { + var e = t._header.size; + (t._paxGlobal = o.decodePax(r.slice(0, e))), r.consume(e), u(); + }, + d = function () { + var e = t._header.size; + (t._pax = o.decodePax(r.slice(0, e))), + t._paxGlobal && + (t._pax = Object.assign({}, t._paxGlobal, t._pax)), + r.consume(e), + u(); + }, + C = function () { + var A = t._header.size; + (this._gnuLongPath = o.decodeLongPath( + r.slice(0, A), + e.filenameEncoding + )), + r.consume(A), + u(); + }, + f = function () { + var A = t._header.size; + (this._gnuLongLinkPath = o.decodeLongPath( + r.slice(0, A), + e.filenameEncoding + )), + r.consume(A), + u(); + }, + I = function () { + var n, + i = t._offset; + try { + n = t._header = o.decode(r.slice(0, 512), e.filenameEncoding); + } catch (e) { + t.emit('error', e); + } + return ( + r.consume(512), + n + ? 'gnu-long-path' === n.type + ? (t._parse(n.size, C), void A()) + : 'gnu-long-link-path' === n.type + ? (t._parse(n.size, f), void A()) + : 'pax-global-header' === n.type + ? (t._parse(n.size, p), void A()) + : 'pax-header' === n.type + ? (t._parse(n.size, d), void A()) + : (t._gnuLongPath && + ((n.name = t._gnuLongPath), (t._gnuLongPath = null)), + t._gnuLongLinkPath && + ((n.linkname = t._gnuLongLinkPath), + (t._gnuLongLinkPath = null)), + t._pax && + ((t._header = n = (function (e, t) { + return ( + t.path && (e.name = t.path), + t.linkpath && (e.linkname = t.linkpath), + t.size && (e.size = parseInt(t.size, 10)), + (e.pax = t), + e + ); + })(n, t._pax)), + (t._pax = null)), + (t._locked = !0), + n.size && 'directory' !== n.type + ? ((t._stream = new g(t, i)), + t.emit('entry', n, t._stream, s), + t._parse(n.size, u), + void A()) + : (t._parse(512, I), + void t.emit( + 'entry', + n, + (function (e, t) { + var r = new g(e, t); + return r.end(), r; + })(t, i), + s + ))) + : (t._parse(512, I), void A()) + ); + }; + (this._onheader = I), this._parse(512, I); + }; + A.inherits(l, i), + (l.prototype.destroy = function (e) { + this._destroyed || + ((this._destroyed = !0), + e && this.emit('error', e), + this.emit('close'), + this._stream && this._stream.emit('close')); + }), + (l.prototype._parse = function (e, t) { + this._destroyed || + ((this._offset += e), + (this._missing = e), + t === this._onheader && (this._partial = !1), + (this._onparse = t)); + }), + (l.prototype._continue = function () { + if (!this._destroyed) { + var e = this._cb; + (this._cb = a), + this._overflow ? this._write(this._overflow, void 0, e) : e(); + } + }), + (l.prototype._write = function (e, t, r) { + if (!this._destroyed) { + var A = this._stream, + n = this._buffer, + o = this._missing; + if ((e.length && (this._partial = !0), e.length < o)) + return ( + (this._missing -= e.length), + (this._overflow = null), + A ? A.write(e, r) : (n.append(e), r()) + ); + (this._cb = r), (this._missing = 0); + var i = null; + e.length > o && ((i = e.slice(o)), (e = e.slice(0, o))), + A ? A.end(e) : n.append(e), + (this._overflow = i), + this._onparse(); + } + }), + (l.prototype._final = function (e) { + if (this._partial) + return this.destroy(new Error('Unexpected end of data')); + e(); + }), + (e.exports = l); + }, + 77686: (e, t) => { + var r = Buffer.alloc, + A = '0'.charCodeAt(0), + n = parseInt('7777', 8), + o = function (e, t, r, A) { + for (; r < A; r++) if (e[r] === t) return r; + return A; + }, + i = function (e) { + for (var t = 256, r = 0; r < 148; r++) t += e[r]; + for (var A = 156; A < 512; A++) t += e[A]; + return t; + }, + s = function (e, t) { + return (e = e.toString(8)).length > t + ? '7777777777777777777'.slice(0, t) + ' ' + : '0000000000000000000'.slice(0, t - e.length) + e + ' '; + }; + var a = function (e, t, r) { + if (128 & (e = e.slice(t, t + r))[(t = 0)]) + return (function (e) { + var t; + if (128 === e[0]) t = !0; + else { + if (255 !== e[0]) return null; + t = !1; + } + for (var r = !1, A = [], n = e.length - 1; n > 0; n--) { + var o = e[n]; + t + ? A.push(o) + : r && 0 === o + ? A.push(0) + : r + ? ((r = !1), A.push(256 - o)) + : A.push(255 - o); + } + var i = 0, + s = A.length; + for (n = 0; n < s; n++) i += A[n] * Math.pow(256, n); + return t ? i : -1 * i; + })(e); + for (; t < e.length && 32 === e[t]; ) t++; + for ( + var A = + ((n = o(e, 32, t, e.length)), + (i = e.length), + (s = e.length), + 'number' != typeof n + ? s + : (n = ~~n) >= i + ? i + : n >= 0 || (n += i) >= 0 + ? n + : 0); + t < A && 0 === e[t]; + + ) + t++; + return A === t ? 0 : parseInt(e.slice(t, A).toString(), 8); + var n, i, s; + }, + c = function (e, t, r, A) { + return e.slice(t, o(e, 0, t, t + r)).toString(A); + }, + g = function (e) { + var t = Buffer.byteLength(e), + r = Math.floor(Math.log(t) / Math.log(10)) + 1; + return t + r >= Math.pow(10, r) && r++, t + r + e; + }; + (t.decodeLongPath = function (e, t) { + return c(e, 0, e.length, t); + }), + (t.encodePax = function (e) { + var t = ''; + e.name && (t += g(' path=' + e.name + '\n')), + e.linkname && (t += g(' linkpath=' + e.linkname + '\n')); + var r = e.pax; + if (r) for (var A in r) t += g(' ' + A + '=' + r[A] + '\n'); + return Buffer.from(t); + }), + (t.decodePax = function (e) { + for (var t = {}; e.length; ) { + for (var r = 0; r < e.length && 32 !== e[r]; ) r++; + var A = parseInt(e.slice(0, r).toString(), 10); + if (!A) return t; + var n = e.slice(r + 1, A - 1).toString(), + o = n.indexOf('='); + if (-1 === o) return t; + (t[n.slice(0, o)] = n.slice(o + 1)), (e = e.slice(A)); + } + return t; + }), + (t.encode = function (e) { + var t = r(512), + o = e.name, + a = ''; + if ( + (5 === e.typeflag && '/' !== o[o.length - 1] && (o += '/'), + Buffer.byteLength(o) !== o.length) + ) + return null; + for (; Buffer.byteLength(o) > 100; ) { + var c = o.indexOf('/'); + if (-1 === c) return null; + (a += a ? '/' + o.slice(0, c) : o.slice(0, c)), + (o = o.slice(c + 1)); + } + return Buffer.byteLength(o) > 100 || + Buffer.byteLength(a) > 155 || + (e.linkname && Buffer.byteLength(e.linkname) > 100) + ? null + : (t.write(o), + t.write(s(e.mode & n, 6), 100), + t.write(s(e.uid, 6), 108), + t.write(s(e.gid, 6), 116), + t.write(s(e.size, 11), 124), + t.write(s((e.mtime.getTime() / 1e3) | 0, 11), 136), + (t[156] = + A + + (function (e) { + switch (e) { + case 'file': + return 0; + case 'link': + return 1; + case 'symlink': + return 2; + case 'character-device': + return 3; + case 'block-device': + return 4; + case 'directory': + return 5; + case 'fifo': + return 6; + case 'contiguous-file': + return 7; + case 'pax-header': + return 72; + } + return 0; + })(e.type)), + e.linkname && t.write(e.linkname, 157), + t.write('ustar\x0000', 257), + e.uname && t.write(e.uname, 265), + e.gname && t.write(e.gname, 297), + t.write(s(e.devmajor || 0, 6), 329), + t.write(s(e.devminor || 0, 6), 337), + a && t.write(a, 345), + t.write(s(i(t), 6), 148), + t); + }), + (t.decode = function (e, t) { + var r = 0 === e[156] ? 0 : e[156] - A, + n = c(e, 0, 100, t), + o = a(e, 100, 8), + s = a(e, 108, 8), + g = a(e, 116, 8), + l = a(e, 124, 12), + u = a(e, 136, 12), + h = (function (e) { + switch (e) { + case 0: + return 'file'; + case 1: + return 'link'; + case 2: + return 'symlink'; + case 3: + return 'character-device'; + case 4: + return 'block-device'; + case 5: + return 'directory'; + case 6: + return 'fifo'; + case 7: + return 'contiguous-file'; + case 72: + return 'pax-header'; + case 55: + return 'pax-global-header'; + case 27: + return 'gnu-long-link-path'; + case 28: + case 30: + return 'gnu-long-path'; + } + return null; + })(r), + p = 0 === e[157] ? null : c(e, 157, 100, t), + d = c(e, 265, 32), + C = c(e, 297, 32), + f = a(e, 329, 8), + I = a(e, 337, 8); + e[345] && (n = c(e, 345, 155, t) + '/' + n), + 0 === r && n && '/' === n[n.length - 1] && (r = 5); + var E = i(e); + if (256 === E) return null; + if (E !== a(e, 148, 8)) + throw new Error( + 'Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?' + ); + return { + name: n, + mode: o, + uid: s, + gid: g, + size: l, + mtime: new Date(1e3 * u), + type: h, + linkname: p, + uname: d, + gname: C, + devmajor: f, + devminor: I, + }; + }); + }, + 59938: (e, t, r) => { + (t.extract = r(75799)), (t.pack = r(72203)); + }, + 72203: (e, t, r) => { + var A = r(13302), + n = r(17067), + o = r(85870), + i = Buffer.alloc, + s = r(86897).Readable, + a = r(86897).Writable, + c = r(24304).StringDecoder, + g = r(77686), + l = parseInt('755', 8), + u = parseInt('644', 8), + h = i(1024), + p = function () {}, + d = function (e, t) { + (t &= 511) && e.push(h.slice(0, 512 - t)); + }; + var C = function (e) { + a.call(this), + (this.written = 0), + (this._to = e), + (this._destroyed = !1); + }; + o(C, a), + (C.prototype._write = function (e, t, r) { + if (((this.written += e.length), this._to.push(e))) return r(); + this._to._drain = r; + }), + (C.prototype.destroy = function () { + this._destroyed || ((this._destroyed = !0), this.emit('close')); + }); + var f = function () { + a.call(this), + (this.linkname = ''), + (this._decoder = new c('utf-8')), + (this._destroyed = !1); + }; + o(f, a), + (f.prototype._write = function (e, t, r) { + (this.linkname += this._decoder.write(e)), r(); + }), + (f.prototype.destroy = function () { + this._destroyed || ((this._destroyed = !0), this.emit('close')); + }); + var I = function () { + a.call(this), (this._destroyed = !1); + }; + o(I, a), + (I.prototype._write = function (e, t, r) { + r(new Error('No body allowed for this entry')); + }), + (I.prototype.destroy = function () { + this._destroyed || ((this._destroyed = !0), this.emit('close')); + }); + var E = function (e) { + if (!(this instanceof E)) return new E(e); + s.call(this, e), + (this._drain = p), + (this._finalized = !1), + (this._finalizing = !1), + (this._destroyed = !1), + (this._stream = null); + }; + o(E, s), + (E.prototype.entry = function (e, t, r) { + if (this._stream) throw new Error('already piping an entry'); + if (!this._finalized && !this._destroyed) { + 'function' == typeof t && ((r = t), (t = null)), r || (r = p); + var o = this; + if ( + ((e.size && 'symlink' !== e.type) || (e.size = 0), + e.type || + (e.type = (function (e) { + switch (e & A.S_IFMT) { + case A.S_IFBLK: + return 'block-device'; + case A.S_IFCHR: + return 'character-device'; + case A.S_IFDIR: + return 'directory'; + case A.S_IFIFO: + return 'fifo'; + case A.S_IFLNK: + return 'symlink'; + } + return 'file'; + })(e.mode)), + e.mode || (e.mode = 'directory' === e.type ? l : u), + e.uid || (e.uid = 0), + e.gid || (e.gid = 0), + e.mtime || (e.mtime = new Date()), + 'string' == typeof t && (t = Buffer.from(t)), + Buffer.isBuffer(t)) + ) + return ( + (e.size = t.length), + this._encode(e), + this.push(t), + d(o, e.size), + process.nextTick(r), + new I() + ); + if ('symlink' === e.type && !e.linkname) { + var i = new f(); + return ( + n(i, function (t) { + if (t) return o.destroy(), r(t); + (e.linkname = i.linkname), o._encode(e), r(); + }), + i + ); + } + if ( + (this._encode(e), + 'file' !== e.type && 'contiguous-file' !== e.type) + ) + return process.nextTick(r), new I(); + var s = new C(this); + return ( + (this._stream = s), + n(s, function (t) { + return ( + (o._stream = null), + t + ? (o.destroy(), r(t)) + : s.written !== e.size + ? (o.destroy(), r(new Error('size mismatch'))) + : (d(o, e.size), o._finalizing && o.finalize(), void r()) + ); + }), + s + ); + } + }), + (E.prototype.finalize = function () { + this._stream + ? (this._finalizing = !0) + : this._finalized || + ((this._finalized = !0), this.push(h), this.push(null)); + }), + (E.prototype.destroy = function (e) { + this._destroyed || + ((this._destroyed = !0), + e && this.emit('error', e), + this.emit('close'), + this._stream && this._stream.destroy && this._stream.destroy()); + }), + (E.prototype._encode = function (e) { + if (!e.pax) { + var t = g.encode(e); + if (t) return void this.push(t); + } + this._encodePax(e); + }), + (E.prototype._encodePax = function (e) { + var t = g.encodePax({ + name: e.name, + linkname: e.linkname, + pax: e.pax, + }), + r = { + name: 'PaxHeader', + mode: e.mode, + uid: e.uid, + gid: e.gid, + size: t.length, + mtime: e.mtime, + type: 'pax-header', + linkname: e.linkname && 'PaxHeader', + uname: e.uname, + gname: e.gname, + devmajor: e.devmajor, + devminor: e.devminor, + }; + this.push(g.encode(r)), + this.push(t), + d(this, t.length), + (r.size = e.size), + (r.type = e.type), + this.push(g.encode(r)); + }), + (E.prototype._read = function (e) { + var t = this._drain; + (this._drain = p), t(); + }), + (e.exports = E); + }, + 84615: (e, t, r) => { + 'use strict'; + /*! + * to-regex-range + * + * Copyright (c) 2015-present, Jon Schlinkert. + * Released under the MIT License. + */ const A = r(59235), + n = (e, t, r) => { + if (!1 === A(e)) + throw new TypeError( + 'toRegexRange: expected the first argument to be a number' + ); + if (void 0 === t || e === t) return String(e); + if (!1 === A(t)) + throw new TypeError( + 'toRegexRange: expected the second argument to be a number.' + ); + let o = { relaxZeros: !0, ...r }; + 'boolean' == typeof o.strictZeros && + (o.relaxZeros = !1 === o.strictZeros); + let a = + e + + ':' + + t + + '=' + + String(o.relaxZeros) + + String(o.shorthand) + + String(o.capture) + + String(o.wrap); + if (n.cache.hasOwnProperty(a)) return n.cache[a].result; + let c = Math.min(e, t), + g = Math.max(e, t); + if (1 === Math.abs(c - g)) { + let r = e + '|' + t; + return o.capture ? `(${r})` : !1 === o.wrap ? r : `(?:${r})`; + } + let l = p(e) || p(t), + u = { min: e, max: t, a: c, b: g }, + h = [], + d = []; + if ( + (l && ((u.isPadded = l), (u.maxLen = String(u.max).length)), + c < 0) + ) { + (d = i(g < 0 ? Math.abs(g) : 1, Math.abs(c), u, o)), + (c = u.a = 0); + } + return ( + g >= 0 && (h = i(c, g, u, o)), + (u.negatives = d), + (u.positives = h), + (u.result = (function (e, t, r) { + let A = s(e, t, '-', !1, r) || [], + n = s(t, e, '', !1, r) || [], + o = s(e, t, '-?', !0, r) || []; + return A.concat(o).concat(n).join('|'); + })(d, h, o)), + !0 === o.capture + ? (u.result = `(${u.result})`) + : !1 !== o.wrap && + h.length + d.length > 1 && + (u.result = `(?:${u.result})`), + (n.cache[a] = u), + u.result + ); + }; + function o(e, t, r) { + if (e === t) return { pattern: e, count: [], digits: 0 }; + let A = (function (e, t) { + let r = []; + for (let A = 0; A < e.length; A++) r.push([e[A], t[A]]); + return r; + })(e, t), + n = A.length, + o = '', + i = 0; + for (let e = 0; e < n; e++) { + let [t, n] = A[e]; + t === n + ? (o += t) + : '0' !== t || '9' !== n + ? (o += h(t, n, r)) + : i++; + } + return ( + i && (o += !0 === r.shorthand ? '\\d' : '[0-9]'), + { pattern: o, count: [i], digits: n } + ); + } + function i(e, t, r, A) { + let n, + i = (function (e, t) { + let r = 1, + A = 1, + n = g(e, r), + o = new Set([t]); + for (; e <= n && n <= t; ) o.add(n), (r += 1), (n = g(e, r)); + for (n = l(t + 1, A) - 1; e < n && n <= t; ) + o.add(n), (A += 1), (n = l(t + 1, A) - 1); + return (o = [...o]), o.sort(a), o; + })(e, t), + s = [], + c = e; + for (let e = 0; e < i.length; e++) { + let t = i[e], + a = o(String(c), String(t), A), + g = ''; + r.isPadded || !n || n.pattern !== a.pattern + ? (r.isPadded && (g = d(t, r, A)), + (a.string = g + a.pattern + u(a.count)), + s.push(a), + (c = t + 1), + (n = a)) + : (n.count.length > 1 && n.count.pop(), + n.count.push(a.count[0]), + (n.string = n.pattern + u(n.count)), + (c = t + 1)); + } + return s; + } + function s(e, t, r, A, n) { + let o = []; + for (let n of e) { + let { string: e } = n; + A || c(t, 'string', e) || o.push(r + e), + A && c(t, 'string', e) && o.push(r + e); + } + return o; + } + function a(e, t) { + return e > t ? 1 : t > e ? -1 : 0; + } + function c(e, t, r) { + return e.some((e) => e[t] === r); + } + function g(e, t) { + return Number(String(e).slice(0, -t) + '9'.repeat(t)); + } + function l(e, t) { + return e - (e % Math.pow(10, t)); + } + function u(e) { + let [t = 0, r = ''] = e; + return r || t > 1 ? `{${t + (r ? ',' + r : '')}}` : ''; + } + function h(e, t, r) { + return `[${e}${t - e == 1 ? '' : '-'}${t}]`; + } + function p(e) { + return /^-?(0+)\d/.test(e); + } + function d(e, t, r) { + if (!t.isPadded) return e; + let A = Math.abs(t.maxLen - String(e).length), + n = !1 !== r.relaxZeros; + switch (A) { + case 0: + return ''; + case 1: + return n ? '0?' : '0'; + case 2: + return n ? '0{0,2}' : '00'; + default: + return n ? `0{0,${A}}` : `0{${A}}`; + } + } + (n.cache = {}), (n.clearCache = () => (n.cache = {})), (e.exports = n); + }, + 75158: (e) => { + function t(e, t) { + var r = e.length, + A = new Array(r), + n = {}, + o = r, + i = (function (e) { + for (var t = new Map(), r = 0, A = e.length; r < A; r++) { + var n = e[r]; + t.has(n[0]) || t.set(n[0], new Set()), + t.has(n[1]) || t.set(n[1], new Set()), + t.get(n[0]).add(n[1]); + } + return t; + })(t), + s = (function (e) { + for (var t = new Map(), r = 0, A = e.length; r < A; r++) + t.set(e[r], r); + return t; + })(e); + for ( + t.forEach(function (e) { + if (!s.has(e[0]) || !s.has(e[1])) + throw new Error( + 'Unknown node. There is an unknown node in the supplied edges.' + ); + }); + o--; + + ) + n[o] || a(e[o], o, new Set()); + return A; + function a(e, t, o) { + if (o.has(e)) { + var c; + try { + c = ', node was:' + JSON.stringify(e); + } catch (e) { + c = ''; + } + throw new Error('Cyclic dependency' + c); + } + if (!s.has(e)) + throw new Error( + 'Found unknown node. Make sure to provided all involved nodes. Unknown node: ' + + JSON.stringify(e) + ); + if (!n[t]) { + n[t] = !0; + var g = i.get(e) || new Set(); + if ((t = (g = Array.from(g)).length)) { + o.add(e); + do { + var l = g[--t]; + a(l, s.get(l), o); + } while (t); + o.delete(e); + } + A[--r] = e; + } + } + } + (e.exports = function (e) { + return t( + (function (e) { + for (var t = new Set(), r = 0, A = e.length; r < A; r++) { + var n = e[r]; + t.add(n[0]), t.add(n[1]); + } + return Array.from(t); + })(e), + e + ); + }), + (e.exports.array = t); + }, + 94682: function (e) { + e.exports = (function () { + function e(t, r, A, n, o, i, s) { + var a, + c, + g = '', + l = 0, + u = n.slice(0); + if ( + (u.push([r, A]) && + n.length > 0 && + (n.forEach(function (e, t) { + t > 0 && (g += (e[1] ? ' ' : '│') + ' '), + c || e[0] !== r || (c = !0); + }), + (g += + (function (e, t) { + var r = t ? '└' : '├'; + return (r += e ? '─ ' : '──┐'); + })(t, A) + t), + o && + ('object' != typeof r || r instanceof Date) && + (g += ': ' + r), + c && (g += ' (circular ref.)'), + s(g)), + !c && 'object' == typeof r) + ) { + var h = (function (e, t) { + var r = []; + for (var A in e) + e.hasOwnProperty(A) && + ((t && 'function' == typeof e[A]) || r.push(A)); + return r; + })(r, i); + h.forEach(function (t) { + (a = ++l === h.length), e(t, r[t], a, u, o, i, s); + }); + } + } + var t = { + asLines: function (t, r, A, n) { + e('.', t, !1, [], r, 'function' != typeof A && A, n || A); + }, + asTree: function (t, r, A) { + var n = ''; + return ( + e('.', t, !1, [], r, A, function (e) { + n += e + '\n'; + }), + n + ); + }, + }; + return t; + })(); + }, + 36370: (e, t, r) => { + 'use strict'; + r.d(t, { gn: () => A }); + function A(e, t, r, A) { + var n, + o = arguments.length, + i = + o < 3 + ? t + : null === A + ? (A = Object.getOwnPropertyDescriptor(t, r)) + : A; + if ( + 'object' == typeof Reflect && + 'function' == typeof Reflect.decorate + ) + i = Reflect.decorate(e, t, r, A); + else + for (var s = e.length - 1; s >= 0; s--) + (n = e[s]) && + (i = (o < 3 ? n(i) : o > 3 ? n(t, r, i) : n(t, r)) || i); + return o > 3 && i && Object.defineProperty(t, r, i), i; + } + }, + 98161: (e, t, r) => { + e.exports = r(69876); + }, + 69876: (e, t, r) => { + 'use strict'; + r(11631); + var A, + n = r(4016), + o = r(98605), + i = r(57211), + s = r(28614), + a = (r(42357), r(31669)); + function c(e) { + var t = this; + (t.options = e || {}), + (t.proxyOptions = t.options.proxy || {}), + (t.maxSockets = t.options.maxSockets || o.Agent.defaultMaxSockets), + (t.requests = []), + (t.sockets = []), + t.on('free', function (e, r, A, n) { + for ( + var o = l(r, A, n), i = 0, s = t.requests.length; + i < s; + ++i + ) { + var a = t.requests[i]; + if (a.host === o.host && a.port === o.port) + return t.requests.splice(i, 1), void a.request.onSocket(e); + } + e.destroy(), t.removeSocket(e); + }); + } + function g(e, t) { + var r = this; + c.prototype.createSocket.call(r, e, function (A) { + var o = e.request.getHeader('host'), + i = u({}, r.options, { + socket: A, + servername: o ? o.replace(/:.*$/, '') : e.host, + }), + s = n.connect(0, i); + (r.sockets[r.sockets.indexOf(A)] = s), t(s); + }); + } + function l(e, t, r) { + return 'string' == typeof e + ? { host: e, port: t, localAddress: r } + : e; + } + function u(e) { + for (var t = 1, r = arguments.length; t < r; ++t) { + var A = arguments[t]; + if ('object' == typeof A) + for (var n = Object.keys(A), o = 0, i = n.length; o < i; ++o) { + var s = n[o]; + void 0 !== A[s] && (e[s] = A[s]); + } + } + return e; + } + (t.httpOverHttp = function (e) { + var t = new c(e); + return (t.request = o.request), t; + }), + (t.httpsOverHttp = function (e) { + var t = new c(e); + return ( + (t.request = o.request), + (t.createSocket = g), + (t.defaultPort = 443), + t + ); + }), + a.inherits(c, s.EventEmitter), + (c.prototype.addRequest = function (e, t, r, A) { + var n = this, + o = u({ request: e }, n.options, l(t, r, A)); + n.sockets.length >= this.maxSockets + ? n.requests.push(o) + : n.createSocket(o, function (t) { + function r() { + n.emit('free', t, o); + } + function A(e) { + n.removeSocket(t), + t.removeListener('free', r), + t.removeListener('close', A), + t.removeListener('agentRemove', A); + } + t.on('free', r), + t.on('close', A), + t.on('agentRemove', A), + e.onSocket(t); + }); + }), + (c.prototype.createSocket = function (e, t) { + var r = this, + n = {}; + r.sockets.push(n); + var o = u({}, r.proxyOptions, { + method: 'CONNECT', + path: e.host + ':' + e.port, + agent: !1, + headers: { host: e.host + ':' + e.port }, + }); + e.localAddress && (o.localAddress = e.localAddress), + o.proxyAuth && + ((o.headers = o.headers || {}), + (o.headers['Proxy-Authorization'] = + 'Basic ' + new Buffer(o.proxyAuth).toString('base64'))), + A('making CONNECT request'); + var i = r.request(o); + function s(o, s, a) { + var c; + return ( + i.removeAllListeners(), + s.removeAllListeners(), + 200 !== o.statusCode + ? (A( + 'tunneling socket could not be established, statusCode=%d', + o.statusCode + ), + s.destroy(), + ((c = new Error( + 'tunneling socket could not be established, statusCode=' + + o.statusCode + )).code = 'ECONNRESET'), + e.request.emit('error', c), + void r.removeSocket(n)) + : a.length > 0 + ? (A('got illegal response body from proxy'), + s.destroy(), + ((c = new Error( + 'got illegal response body from proxy' + )).code = 'ECONNRESET'), + e.request.emit('error', c), + void r.removeSocket(n)) + : (A('tunneling connection has established'), + (r.sockets[r.sockets.indexOf(n)] = s), + t(s)) + ); + } + (i.useChunkedEncodingByDefault = !1), + i.once('response', function (e) { + e.upgrade = !0; + }), + i.once('upgrade', function (e, t, r) { + process.nextTick(function () { + s(e, t, r); + }); + }), + i.once('connect', s), + i.once('error', function (t) { + i.removeAllListeners(), + A( + 'tunneling socket could not be established, cause=%s\n', + t.message, + t.stack + ); + var o = new Error( + 'tunneling socket could not be established, cause=' + + t.message + ); + (o.code = 'ECONNRESET'), + e.request.emit('error', o), + r.removeSocket(n); + }), + i.end(); + }), + (c.prototype.removeSocket = function (e) { + var t = this.sockets.indexOf(e); + if (-1 !== t) { + this.sockets.splice(t, 1); + var r = this.requests.shift(); + r && + this.createSocket(r, function (e) { + r.request.onSocket(e); + }); + } + }), + (A = + process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG) + ? function () { + var e = Array.prototype.slice.call(arguments); + 'string' == typeof e[0] + ? (e[0] = 'TUNNEL: ' + e[0]) + : e.unshift('TUNNEL:'), + console.error.apply(console, e); + } + : function () {}); + }, + 73212: (e, t, r) => { + e.exports = r(31669).deprecate; + }, + 87945: (e, t, r) => { + const A = + 'win32' === process.platform || + 'cygwin' === process.env.OSTYPE || + 'msys' === process.env.OSTYPE, + n = r(85622), + o = A ? ';' : ':', + i = r(64151), + s = (e) => + Object.assign(new Error('not found: ' + e), { code: 'ENOENT' }), + a = (e, t) => { + const r = t.colon || o, + n = + e.match(/\//) || (A && e.match(/\\/)) + ? [''] + : [ + ...(A ? [process.cwd()] : []), + ...(t.path || process.env.PATH || '').split(r), + ], + i = A + ? t.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM' + : '', + s = A ? i.split(r) : ['']; + return ( + A && -1 !== e.indexOf('.') && '' !== s[0] && s.unshift(''), + { pathEnv: n, pathExt: s, pathExtExe: i } + ); + }, + c = (e, t, r) => { + 'function' == typeof t && ((r = t), (t = {})), t || (t = {}); + const { pathEnv: A, pathExt: o, pathExtExe: c } = a(e, t), + g = [], + l = (r) => + new Promise((o, i) => { + if (r === A.length) return t.all && g.length ? o(g) : i(s(e)); + const a = A[r], + c = /^".*"$/.test(a) ? a.slice(1, -1) : a, + l = n.join(c, e), + h = !c && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + l : l; + o(u(h, r, 0)); + }), + u = (e, r, A) => + new Promise((n, s) => { + if (A === o.length) return n(l(r + 1)); + const a = o[A]; + i(e + a, { pathExt: c }, (o, i) => { + if (!o && i) { + if (!t.all) return n(e + a); + g.push(e + a); + } + return n(u(e, r, A + 1)); + }); + }); + return r ? l(0).then((e) => r(null, e), r) : l(0); + }; + (e.exports = c), + (c.sync = (e, t) => { + t = t || {}; + const { pathEnv: r, pathExt: A, pathExtExe: o } = a(e, t), + c = []; + for (let s = 0; s < r.length; s++) { + const a = r[s], + g = /^".*"$/.test(a) ? a.slice(1, -1) : a, + l = n.join(g, e), + u = !g && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + l : l; + for (let e = 0; e < A.length; e++) { + const r = u + A[e]; + try { + if (i.sync(r, { pathExt: o })) { + if (!t.all) return r; + c.push(r); + } + } catch (e) {} + } + } + if (t.all && c.length) return c; + if (t.nothrow) return null; + throw s(e); + }); + }, + 98984: (e) => { + e.exports = function e(t, r) { + if (t && r) return e(t)(r); + if ('function' != typeof t) + throw new TypeError('need wrapper function'); + return ( + Object.keys(t).forEach(function (e) { + A[e] = t[e]; + }), + A + ); + function A() { + for (var e = new Array(arguments.length), r = 0; r < e.length; r++) + e[r] = arguments[r]; + var A = t.apply(this, e), + n = e[e.length - 1]; + return ( + 'function' == typeof A && + A !== n && + Object.keys(n).forEach(function (e) { + A[e] = n[e]; + }), + A + ); + } + }; + }, + 94916: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = void 0); + var n = A(r(15215)), + o = A(r(11050)), + i = (function () { + function e(e, t) { + if (((this.refs = e), 'function' != typeof t)) { + if (!(0, n.default)(t, 'is')) + throw new TypeError( + '`is:` is required for `when()` conditions' + ); + if (!t.then && !t.otherwise) + throw new TypeError( + 'either `then:` or `otherwise:` is required for `when()` conditions' + ); + var r = t.is, + A = t.then, + o = t.otherwise, + i = + 'function' == typeof r + ? r + : function () { + for ( + var e = arguments.length, t = new Array(e), A = 0; + A < e; + A++ + ) + t[A] = arguments[A]; + return t.every(function (e) { + return e === r; + }); + }; + this.fn = function () { + for ( + var e = arguments.length, t = new Array(e), r = 0; + r < e; + r++ + ) + t[r] = arguments[r]; + var n = t.pop(), + s = t.pop(), + a = i.apply(void 0, t) ? A : o; + if (a) + return 'function' == typeof a + ? a(s) + : s.concat(a.resolve(n)); + }; + } else this.fn = t; + } + return ( + (e.prototype.resolve = function (e, t) { + var r = this.refs.map(function (e) { + return e.getValue(t); + }), + A = this.fn.apply(e, r.concat(e, t)); + if (void 0 === A || A === e) return e; + if (!(0, o.default)(A)) + throw new TypeError('conditions must return a schema object'); + return A.resolve(t); + }), + e + ); + })(); + (t.default = i), (e.exports = t.default); + }, + 6856: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = void 0); + var n = A(r(11050)), + o = (function () { + function e(e) { + this._resolve = function (t, r) { + var A = e(t, r); + if (!(0, n.default)(A)) + throw new TypeError( + 'lazy() functions must return a valid schema' + ); + return A.resolve(r); + }; + } + var t = e.prototype; + return ( + (t.resolve = function (e) { + return this._resolve(e.value, e); + }), + (t.cast = function (e, t) { + return this._resolve(e, t).cast(e, t); + }), + (t.validate = function (e, t) { + return this._resolve(e, t).validate(e, t); + }), + (t.validateSync = function (e, t) { + return this._resolve(e, t).validateSync(e, t); + }), + (t.validateAt = function (e, t, r) { + return this._resolve(t, r).validateAt(e, t, r); + }), + (t.validateSyncAt = function (e, t, r) { + return this._resolve(t, r).validateSyncAt(e, t, r); + }), + e + ); + })(); + o.prototype.__isYupSchema__ = !0; + var i = o; + (t.default = i), (e.exports = t.default); + }, + 95814: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = void 0); + var n = A(r(72912)), + o = r(79588), + i = '$', + s = '.', + a = (function () { + function e(e, t) { + if ((void 0 === t && (t = {}), 'string' != typeof e)) + throw new TypeError('ref must be a string, got: ' + e); + if (((this.key = e.trim()), '' === e)) + throw new TypeError('ref must be a non-empty string'); + (this.isContext = this.key[0] === i), + (this.isValue = this.key[0] === s), + (this.isSibling = !this.isContext && !this.isValue); + var r = this.isContext ? i : this.isValue ? s : ''; + (this.path = this.key.slice(r.length)), + (this.getter = this.path && (0, o.getter)(this.path, !0)), + (this.map = t.map); + } + var t = e.prototype; + return ( + (t.getValue = function (e) { + var t = this.isContext + ? e.context + : this.isValue + ? e.value + : e.parent; + return ( + this.getter && (t = this.getter(t || {})), + this.map && (t = this.map(t)), + t + ); + }), + (t.cast = function (e, t) { + return this.getValue((0, n.default)({}, t, { value: e })); + }), + (t.resolve = function () { + return this; + }), + (t.describe = function () { + return { type: 'ref', key: this.key }; + }), + (t.toString = function () { + return 'Ref(' + this.key + ')'; + }), + (e.isRef = function (e) { + return e && e.__isYupRef; + }), + e + ); + })(); + (t.default = a), (a.prototype.__isYupRef = !0), (e.exports = t.default); + }, + 40828: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = s); + var n = A(r(21043)), + o = /\$\{\s*(\w+)\s*\}/g, + i = function (e) { + return function (t) { + return e.replace(o, function (e, r) { + return (0, n.default)(t[r]); + }); + }; + }; + function s(e, t, r, A) { + var n = this; + (this.name = 'ValidationError'), + (this.value = t), + (this.path = r), + (this.type = A), + (this.errors = []), + (this.inner = []), + e && + [].concat(e).forEach(function (e) { + (n.errors = n.errors.concat(e.errors || e)), + e.inner && + (n.inner = n.inner.concat(e.inner.length ? e.inner : e)); + }), + (this.message = + this.errors.length > 1 + ? this.errors.length + ' errors occurred' + : this.errors[0]), + Error.captureStackTrace && Error.captureStackTrace(this, s); + } + (s.prototype = Object.create(Error.prototype)), + (s.prototype.constructor = s), + (s.isError = function (e) { + return e && 'ValidationError' === e.name; + }), + (s.formatError = function (e, t) { + 'string' == typeof e && (e = i(e)); + var r = function (t) { + return ( + (t.path = t.label || t.path || 'this'), + 'function' == typeof e ? e(t) : e + ); + }; + return 1 === arguments.length ? r : r(t); + }), + (e.exports = t.default); + }, + 18830: (e, t, r) => { + 'use strict'; + var A = r(19228), + n = r(60087); + (t.__esModule = !0), (t.default = void 0); + var o = n(r(72912)), + i = n(r(62407)), + s = n(r(31490)), + a = n(r(71665)), + c = n(r(11050)), + g = n(r(7045)), + l = n(r(21043)), + u = n(r(16434)), + h = r(63802), + p = A(r(80180)); + function d() { + var e = (0, i.default)(['', '[', ']']); + return ( + (d = function () { + return e; + }), + e + ); + } + var C = f; + function f(e) { + var t = this; + if (!(this instanceof f)) return new f(e); + u.default.call(this, { type: 'array' }), + (this._subType = void 0), + this.withMutation(function () { + t.transform(function (e) { + if ('string' == typeof e) + try { + e = JSON.parse(e); + } catch (t) { + e = null; + } + return this.isType(e) ? e : null; + }), + e && t.of(e); + }); + } + (t.default = C), + (0, s.default)(f, u.default, { + _typeCheck: function (e) { + return Array.isArray(e); + }, + _cast: function (e, t) { + var r = this, + A = u.default.prototype._cast.call(this, e, t); + if (!this._typeCheck(A) || !this._subType) return A; + var n = !1, + o = A.map(function (e) { + var A = r._subType.cast(e, t); + return A !== e && (n = !0), A; + }); + return n ? o : A; + }, + _validate: function (e, t) { + var r = this; + void 0 === t && (t = {}); + var A = [], + n = t.sync, + i = t.path, + s = this._subType, + a = this._option('abortEarly', t), + c = this._option('recursive', t), + l = null != t.originalValue ? t.originalValue : e; + return u.default.prototype._validate + .call(this, e, t) + .catch((0, p.propagateErrors)(a, A)) + .then(function (e) { + if (!c || !s || !r._typeCheck(e)) { + if (A.length) throw A[0]; + return e; + } + l = l || e; + var u = e.map(function (r, A) { + var n = (0, g.default)(d(), t.path, A), + i = (0, o.default)({}, t, { + path: n, + strict: !0, + parent: e, + originalValue: l[A], + }); + return !s.validate || s.validate(r, i); + }); + return (0, + p.default)({ sync: n, path: i, value: e, errors: A, endEarly: a, validations: u }); + }); + }, + _isPresent: function (e) { + return u.default.prototype._cast.call(this, e) && e.length > 0; + }, + of: function (e) { + var t = this.clone(); + if (!1 !== e && !(0, c.default)(e)) + throw new TypeError( + '`array.of()` sub-schema must be a valid yup schema, or `false` to negate a current sub-schema. not: ' + + (0, l.default)(e) + ); + return (t._subType = e), t; + }, + min: function (e, t) { + return ( + (t = t || h.array.min), + this.test({ + message: t, + name: 'min', + exclusive: !0, + params: { min: e }, + test: function (t) { + return (0, a.default)(t) || t.length >= this.resolve(e); + }, + }) + ); + }, + max: function (e, t) { + return ( + (t = t || h.array.max), + this.test({ + message: t, + name: 'max', + exclusive: !0, + params: { max: e }, + test: function (t) { + return (0, a.default)(t) || t.length <= this.resolve(e); + }, + }) + ); + }, + ensure: function () { + var e = this; + return this.default(function () { + return []; + }).transform(function (t) { + return e.isType(t) ? t : null === t ? [] : [].concat(t); + }); + }, + compact: function (e) { + var t = e + ? function (t, r, A) { + return !e(t, r, A); + } + : function (e) { + return !!e; + }; + return this.transform(function (e) { + return null != e ? e.filter(t) : e; + }); + }, + describe: function () { + var e = u.default.prototype.describe.call(this); + return ( + this._subType && (e.innerType = this._subType.describe()), e + ); + }, + }), + (e.exports = t.default); + }, + 76595: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = void 0); + var n = A(r(31490)), + o = A(r(16434)), + i = s; + function s() { + var e = this; + if (!(this instanceof s)) return new s(); + o.default.call(this, { type: 'boolean' }), + this.withMutation(function () { + e.transform(function (e) { + if (!this.isType(e)) { + if (/^(true|1)$/i.test(e)) return !0; + if (/^(false|0)$/i.test(e)) return !1; + } + return e; + }); + }); + } + (t.default = i), + (0, n.default)(s, o.default, { + _typeCheck: function (e) { + return ( + e instanceof Boolean && (e = e.valueOf()), 'boolean' == typeof e + ); + }, + }), + (e.exports = t.default); + }, + 41755: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = void 0); + var n = A(r(16434)), + o = A(r(31490)), + i = A(r(76813)), + s = r(63802), + a = A(r(71665)), + c = A(r(95814)), + g = new Date(''), + l = u; + function u() { + var e = this; + if (!(this instanceof u)) return new u(); + n.default.call(this, { type: 'date' }), + this.withMutation(function () { + e.transform(function (e) { + return this.isType(e) + ? e + : (e = (0, i.default)(e)) + ? new Date(e) + : g; + }); + }); + } + (t.default = l), + (0, o.default)(u, n.default, { + _typeCheck: function (e) { + return ( + (t = e), + '[object Date]' === Object.prototype.toString.call(t) && + !isNaN(e.getTime()) + ); + var t; + }, + min: function (e, t) { + void 0 === t && (t = s.date.min); + var r = e; + if ( + !c.default.isRef(r) && + ((r = this.cast(e)), !this._typeCheck(r)) + ) + throw new TypeError( + '`min` must be a Date or a value that can be `cast()` to a Date' + ); + return this.test({ + message: t, + name: 'min', + exclusive: !0, + params: { min: e }, + test: function (e) { + return (0, a.default)(e) || e >= this.resolve(r); + }, + }); + }, + max: function (e, t) { + void 0 === t && (t = s.date.max); + var r = e; + if ( + !c.default.isRef(r) && + ((r = this.cast(e)), !this._typeCheck(r)) + ) + throw new TypeError( + '`max` must be a Date or a value that can be `cast()` to a Date' + ); + return this.test({ + message: t, + name: 'max', + exclusive: !0, + params: { max: e }, + test: function (e) { + return (0, a.default)(e) || e <= this.resolve(r); + }, + }); + }, + }), + (e.exports = t.default); + }, + 15966: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.addMethod = function (e, t, r) { + if (!e || !(0, d.default)(e.prototype)) + throw new TypeError( + 'You must provide a yup schema constructor function' + ); + if ('string' != typeof t) + throw new TypeError('A Method name must be provided'); + if ('function' != typeof r) + throw new TypeError('Method function must be provided'); + e.prototype[t] = r; + }), + (t.lazy = t.ref = t.boolean = void 0); + var n = A(r(16434)); + t.mixed = n.default; + var o = A(r(76595)); + t.bool = o.default; + var i = A(r(45167)); + t.string = i.default; + var s = A(r(72068)); + t.number = s.default; + var a = A(r(41755)); + t.date = a.default; + var c = A(r(51727)); + t.object = c.default; + var g = A(r(18830)); + t.array = g.default; + var l = A(r(95814)), + u = A(r(6856)), + h = A(r(40828)); + t.ValidationError = h.default; + var p = A(r(43910)); + t.reach = p.default; + var d = A(r(11050)); + t.isSchema = d.default; + var C = A(r(24280)); + t.setLocale = C.default; + var f = o.default; + t.boolean = f; + t.ref = function (e, t) { + return new l.default(e, t); + }; + t.lazy = function (e) { + return new u.default(e); + }; + }, + 63802: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.default = t.array = t.object = t.boolean = t.date = t.number = t.string = t.mixed = void 0); + var n = A(r(21043)), + o = { + default: '${path} is invalid', + required: '${path} is a required field', + oneOf: '${path} must be one of the following values: ${values}', + notOneOf: + '${path} must not be one of the following values: ${values}', + notType: function (e) { + var t = e.path, + r = e.type, + A = e.value, + o = e.originalValue, + i = null != o && o !== A, + s = + t + + ' must be a `' + + r + + '` type, but the final value was: `' + + (0, n.default)(A, !0) + + '`' + + (i + ? ' (cast from the value `' + (0, n.default)(o, !0) + '`).' + : '.'); + return ( + null === A && + (s += + '\n If "null" is intended as an empty value be sure to mark the schema as `.nullable()`'), + s + ); + }, + }; + t.mixed = o; + var i = { + length: '${path} must be exactly ${length} characters', + min: '${path} must be at least ${min} characters', + max: '${path} must be at most ${max} characters', + matches: '${path} must match the following: "${regex}"', + email: '${path} must be a valid email', + url: '${path} must be a valid URL', + trim: '${path} must be a trimmed string', + lowercase: '${path} must be a lowercase string', + uppercase: '${path} must be a upper case string', + }; + t.string = i; + var s = { + min: '${path} must be greater than or equal to ${min}', + max: '${path} must be less than or equal to ${max}', + lessThan: '${path} must be less than ${less}', + moreThan: '${path} must be greater than ${more}', + notEqual: '${path} must be not equal to ${notEqual}', + positive: '${path} must be a positive number', + negative: '${path} must be a negative number', + integer: '${path} must be an integer', + }; + t.number = s; + var a = { + min: '${path} field must be later than ${min}', + max: '${path} field must be at earlier than ${max}', + }; + t.date = a; + var c = {}; + t.boolean = c; + var g = { + noUnknown: + '${path} field cannot have keys not specified in the object shape', + }; + t.object = g; + var l = { + min: '${path} field must have at least ${min} items', + max: '${path} field must have less than or equal to ${max} items', + }; + t.array = l; + var u = { + mixed: o, + string: i, + number: s, + date: a, + object: g, + array: l, + boolean: c, + }; + t.default = u; + }, + 16434: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = I); + var n = A(r(72912)), + o = A(r(15215)), + i = A(r(26052)), + s = A(r(78700)), + a = r(63802), + c = A(r(94916)), + g = A(r(80180)), + l = A(r(22808)), + u = A(r(11050)), + h = A(r(54107)), + p = A(r(21043)), + d = A(r(95814)), + C = r(43910), + f = (function () { + function e() { + (this.list = new Set()), (this.refs = new Map()); + } + var t = e.prototype; + return ( + (t.toArray = function () { + return (0, s.default)(this.list).concat( + (0, s.default)(this.refs.values()) + ); + }), + (t.add = function (e) { + d.default.isRef(e) ? this.refs.set(e.key, e) : this.list.add(e); + }), + (t.delete = function (e) { + d.default.isRef(e) + ? this.refs.delete(e.key, e) + : this.list.delete(e); + }), + (t.has = function (e, t) { + if (this.list.has(e)) return !0; + for (var r, A = this.refs.values(); !(r = A.next()).done; ) + if (t(r.value) === e) return !0; + return !1; + }), + e + ); + })(); + function I(e) { + var t = this; + if ((void 0 === e && (e = {}), !(this instanceof I))) return new I(); + (this._deps = []), + (this._conditions = []), + (this._options = { abortEarly: !0, recursive: !0 }), + (this._exclusive = Object.create(null)), + (this._whitelist = new f()), + (this._blacklist = new f()), + (this.tests = []), + (this.transforms = []), + this.withMutation(function () { + t.typeError(a.mixed.notType); + }), + (0, o.default)(e, 'default') && (this._defaultDefault = e.default), + (this._type = e.type || 'mixed'); + } + for ( + var E = (I.prototype = { + __isYupSchema__: !0, + constructor: I, + clone: function () { + var e = this; + return this._mutate + ? this + : (0, i.default)(this, function (t) { + if ((0, u.default)(t) && t !== e) return t; + }); + }, + label: function (e) { + var t = this.clone(); + return (t._label = e), t; + }, + meta: function (e) { + if (0 === arguments.length) return this._meta; + var t = this.clone(); + return (t._meta = (0, n.default)(t._meta || {}, e)), t; + }, + withMutation: function (e) { + var t = this._mutate; + this._mutate = !0; + var r = e(this); + return (this._mutate = t), r; + }, + concat: function (e) { + if (!e || e === this) return this; + if (e._type !== this._type && 'mixed' !== this._type) + throw new TypeError( + "You cannot `concat()` schema's of different types: " + + this._type + + ' and ' + + e._type + ); + var t = (0, l.default)(e.clone(), this); + return ( + (0, o.default)(e, '_default') && (t._default = e._default), + (t.tests = this.tests), + (t._exclusive = this._exclusive), + t.withMutation(function (t) { + e.tests.forEach(function (e) { + t.test(e.OPTIONS); + }); + }), + t + ); + }, + isType: function (e) { + return ( + !(!this._nullable || null !== e) || + !this._typeCheck || + this._typeCheck(e) + ); + }, + resolve: function (e) { + var t = this; + if (t._conditions.length) { + var r = t._conditions; + ((t = t.clone())._conditions = []), + (t = (t = r.reduce(function (t, r) { + return r.resolve(t, e); + }, t)).resolve(e)); + } + return t; + }, + cast: function (e, t) { + void 0 === t && (t = {}); + var r = this.resolve((0, n.default)({}, t, { value: e })), + A = r._cast(e, t); + if (void 0 !== e && !1 !== t.assert && !0 !== r.isType(A)) { + var o = (0, p.default)(e), + i = (0, p.default)(A); + throw new TypeError( + 'The value of ' + + (t.path || 'field') + + ' could not be cast to a value that satisfies the schema type: "' + + r._type + + '". \n\nattempted value: ' + + o + + ' \n' + + (i !== o ? 'result of cast: ' + i : '') + ); + } + return A; + }, + _cast: function (e) { + var t = this, + r = + void 0 === e + ? e + : this.transforms.reduce(function (r, A) { + return A.call(t, r, e); + }, e); + return ( + void 0 === r && + (0, o.default)(this, '_default') && + (r = this.default()), + r + ); + }, + _validate: function (e, t) { + var r = this; + void 0 === t && (t = {}); + var A = e, + o = null != t.originalValue ? t.originalValue : e, + i = this._option('strict', t), + s = this._option('abortEarly', t), + a = t.sync, + c = t.path, + l = this._label; + i || (A = this._cast(A, (0, n.default)({ assert: !1 }, t))); + var u = { + value: A, + path: c, + schema: this, + options: t, + label: l, + originalValue: o, + sync: a, + }, + h = []; + return ( + this._typeError && h.push(this._typeError(u)), + this._whitelistError && h.push(this._whitelistError(u)), + this._blacklistError && h.push(this._blacklistError(u)), + (0, g.default)({ + validations: h, + endEarly: s, + value: A, + path: c, + sync: a, + }).then(function (e) { + return (0, g.default)({ + path: c, + sync: a, + value: e, + endEarly: s, + validations: r.tests.map(function (e) { + return e(u); + }), + }); + }) + ); + }, + validate: function (e, t) { + return ( + void 0 === t && (t = {}), + this.resolve((0, n.default)({}, t, { value: e }))._validate( + e, + t + ) + ); + }, + validateSync: function (e, t) { + var r, A; + if ( + (void 0 === t && (t = {}), + this.resolve((0, n.default)({}, t, { value: e })) + ._validate(e, (0, n.default)({}, t, { sync: !0 })) + .then(function (e) { + return (r = e); + }) + .catch(function (e) { + return (A = e); + }), + A) + ) + throw A; + return r; + }, + isValid: function (e, t) { + return this.validate(e, t) + .then(function () { + return !0; + }) + .catch(function (e) { + if ('ValidationError' === e.name) return !1; + throw e; + }); + }, + isValidSync: function (e, t) { + try { + return this.validateSync(e, t), !0; + } catch (e) { + if ('ValidationError' === e.name) return !1; + throw e; + } + }, + getDefault: function (e) { + return void 0 === e && (e = {}), this.resolve(e).default(); + }, + default: function (e) { + if (0 === arguments.length) { + var t = (0, o.default)(this, '_default') + ? this._default + : this._defaultDefault; + return 'function' == typeof t + ? t.call(this) + : (0, i.default)(t); + } + var r = this.clone(); + return (r._default = e), r; + }, + strict: function (e) { + void 0 === e && (e = !0); + var t = this.clone(); + return (t._options.strict = e), t; + }, + _isPresent: function (e) { + return null != e; + }, + required: function (e) { + return ( + void 0 === e && (e = a.mixed.required), + this.test({ + message: e, + name: 'required', + exclusive: !0, + test: function (e) { + return this.schema._isPresent(e); + }, + }) + ); + }, + notRequired: function () { + var e = this.clone(); + return ( + (e.tests = e.tests.filter(function (e) { + return 'required' !== e.OPTIONS.name; + })), + e + ); + }, + nullable: function (e) { + void 0 === e && (e = !0); + var t = this.clone(); + return (t._nullable = e), t; + }, + transform: function (e) { + var t = this.clone(); + return t.transforms.push(e), t; + }, + test: function () { + var e; + if ( + (void 0 === + (e = + 1 === arguments.length + ? 'function' == + typeof (arguments.length <= 0 ? void 0 : arguments[0]) + ? { + test: + arguments.length <= 0 ? void 0 : arguments[0], + } + : arguments.length <= 0 + ? void 0 + : arguments[0] + : 2 === arguments.length + ? { + name: arguments.length <= 0 ? void 0 : arguments[0], + test: arguments.length <= 1 ? void 0 : arguments[1], + } + : { + name: arguments.length <= 0 ? void 0 : arguments[0], + message: + arguments.length <= 1 ? void 0 : arguments[1], + test: arguments.length <= 2 ? void 0 : arguments[2], + }).message && (e.message = a.mixed.default), + 'function' != typeof e.test) + ) + throw new TypeError('`test` is a required parameters'); + var t = this.clone(), + r = (0, h.default)(e), + A = e.exclusive || (e.name && !0 === t._exclusive[e.name]); + if (e.exclusive && !e.name) + throw new TypeError( + 'Exclusive tests must provide a unique `name` identifying the test' + ); + return ( + (t._exclusive[e.name] = !!e.exclusive), + (t.tests = t.tests.filter(function (t) { + if (t.OPTIONS.name === e.name) { + if (A) return !1; + if (t.OPTIONS.test === r.OPTIONS.test) return !1; + } + return !0; + })), + t.tests.push(r), + t + ); + }, + when: function (e, t) { + 1 === arguments.length && ((t = e), (e = '.')); + var r = this.clone(), + A = [].concat(e).map(function (e) { + return new d.default(e); + }); + return ( + A.forEach(function (e) { + e.isSibling && r._deps.push(e.key); + }), + r._conditions.push(new c.default(A, t)), + r + ); + }, + typeError: function (e) { + var t = this.clone(); + return ( + (t._typeError = (0, h.default)({ + message: e, + name: 'typeError', + test: function (e) { + return ( + !(void 0 !== e && !this.schema.isType(e)) || + this.createError({ + params: { type: this.schema._type }, + }) + ); + }, + })), + t + ); + }, + oneOf: function (e, t) { + void 0 === t && (t = a.mixed.oneOf); + var r = this.clone(); + return ( + e.forEach(function (e) { + r._whitelist.add(e), r._blacklist.delete(e); + }), + (r._whitelistError = (0, h.default)({ + message: t, + name: 'oneOf', + test: function (e) { + if (void 0 === e) return !0; + var t = this.schema._whitelist; + return ( + !!t.has(e, this.resolve) || + this.createError({ + params: { values: t.toArray().join(', ') }, + }) + ); + }, + })), + r + ); + }, + notOneOf: function (e, t) { + void 0 === t && (t = a.mixed.notOneOf); + var r = this.clone(); + return ( + e.forEach(function (e) { + r._blacklist.add(e), r._whitelist.delete(e); + }), + (r._blacklistError = (0, h.default)({ + message: t, + name: 'notOneOf', + test: function (e) { + var t = this.schema._blacklist; + return ( + !t.has(e, this.resolve) || + this.createError({ + params: { values: t.toArray().join(', ') }, + }) + ); + }, + })), + r + ); + }, + strip: function (e) { + void 0 === e && (e = !0); + var t = this.clone(); + return (t._strip = e), t; + }, + _option: function (e, t) { + return (0, o.default)(t, e) ? t[e] : this._options[e]; + }, + describe: function () { + var e = this.clone(); + return { + type: e._type, + meta: e._meta, + label: e._label, + tests: e.tests + .map(function (e) { + return { name: e.OPTIONS.name, params: e.OPTIONS.params }; + }) + .filter(function (e, t, r) { + return ( + r.findIndex(function (t) { + return t.name === e.name; + }) === t + ); + }), + }; + }, + }), + B = ['validate', 'validateSync'], + y = function () { + var e = B[m]; + E[e + 'At'] = function (t, r, A) { + void 0 === A && (A = {}); + var o = (0, C.getIn)(this, t, r, A.context), + i = o.parent, + s = o.parentPath; + return o.schema[e]( + i && i[s], + (0, n.default)({}, A, { parent: i, path: t }) + ); + }; + }, + m = 0; + m < B.length; + m++ + ) + y(); + for (var w = ['equals', 'is'], Q = 0; Q < w.length; Q++) { + E[w[Q]] = E.oneOf; + } + for (var D = ['not', 'nope'], b = 0; b < D.length; b++) { + E[D[b]] = E.notOneOf; + } + (E.optional = E.notRequired), (e.exports = t.default); + }, + 72068: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = c); + var n = A(r(31490)), + o = A(r(16434)), + i = r(63802), + s = A(r(71665)), + a = function (e) { + return (0, s.default)(e) || e === (0 | e); + }; + function c() { + var e = this; + if (!(this instanceof c)) return new c(); + o.default.call(this, { type: 'number' }), + this.withMutation(function () { + e.transform(function (e) { + var t = e; + if ('string' == typeof t) { + if ('' === (t = t.replace(/\s/g, ''))) return NaN; + t = +t; + } + return this.isType(t) ? t : parseFloat(t); + }); + }); + } + (0, n.default)(c, o.default, { + _typeCheck: function (e) { + return ( + e instanceof Number && (e = e.valueOf()), + 'number' == typeof e && + !(function (e) { + return e != +e; + })(e) + ); + }, + min: function (e, t) { + return ( + void 0 === t && (t = i.number.min), + this.test({ + message: t, + name: 'min', + exclusive: !0, + params: { min: e }, + test: function (t) { + return (0, s.default)(t) || t >= this.resolve(e); + }, + }) + ); + }, + max: function (e, t) { + return ( + void 0 === t && (t = i.number.max), + this.test({ + message: t, + name: 'max', + exclusive: !0, + params: { max: e }, + test: function (t) { + return (0, s.default)(t) || t <= this.resolve(e); + }, + }) + ); + }, + lessThan: function (e, t) { + return ( + void 0 === t && (t = i.number.lessThan), + this.test({ + message: t, + name: 'max', + exclusive: !0, + params: { less: e }, + test: function (t) { + return (0, s.default)(t) || t < this.resolve(e); + }, + }) + ); + }, + moreThan: function (e, t) { + return ( + void 0 === t && (t = i.number.moreThan), + this.test({ + message: t, + name: 'min', + exclusive: !0, + params: { more: e }, + test: function (t) { + return (0, s.default)(t) || t > this.resolve(e); + }, + }) + ); + }, + positive: function (e) { + return void 0 === e && (e = i.number.positive), this.moreThan(0, e); + }, + negative: function (e) { + return void 0 === e && (e = i.number.negative), this.lessThan(0, e); + }, + integer: function (e) { + return ( + void 0 === e && (e = i.number.integer), + this.test({ name: 'integer', message: e, test: a }) + ); + }, + truncate: function () { + return this.transform(function (e) { + return (0, s.default)(e) ? e : 0 | e; + }); + }, + round: function (e) { + var t = ['ceil', 'floor', 'round', 'trunc']; + if ('trunc' === (e = (e && e.toLowerCase()) || 'round')) + return this.truncate(); + if (-1 === t.indexOf(e.toLowerCase())) + throw new TypeError( + 'Only valid options for round() are: ' + t.join(', ') + ); + return this.transform(function (t) { + return (0, s.default)(t) ? t : Math[e](t); + }); + }, + }), + (e.exports = t.default); + }, + 51727: (e, t, r) => { + 'use strict'; + var A = r(19228), + n = r(60087); + (t.__esModule = !0), (t.default = w); + var o = n(r(62407)), + i = n(r(72912)), + s = n(r(15215)), + a = n(r(36494)), + c = n(r(89170)), + g = n(r(5253)), + l = n(r(89612)), + u = r(79588), + h = n(r(16434)), + p = r(63802), + d = n(r(18417)), + C = n(r(23316)), + f = n(r(31490)), + I = n(r(7045)), + E = A(r(80180)); + function B() { + var e = (0, o.default)(['', '.', '']); + return ( + (B = function () { + return e; + }), + e + ); + } + function y() { + var e = (0, o.default)(['', '.', '']); + return ( + (y = function () { + return e; + }), + e + ); + } + var m = function (e) { + return '[object Object]' === Object.prototype.toString.call(e); + }; + function w(e) { + var t = this; + if (!(this instanceof w)) return new w(e); + h.default.call(this, { + type: 'object', + default: function () { + var e = this; + if (this._nodes.length) { + var t = {}; + return ( + this._nodes.forEach(function (r) { + t[r] = e.fields[r].default ? e.fields[r].default() : void 0; + }), + t + ); + } + }, + }), + (this.fields = Object.create(null)), + (this._nodes = []), + (this._excludedEdges = []), + this.withMutation(function () { + t.transform(function (e) { + if ('string' == typeof e) + try { + e = JSON.parse(e); + } catch (t) { + e = null; + } + return this.isType(e) ? e : null; + }), + e && t.shape(e); + }); + } + (0, f.default)(w, h.default, { + _typeCheck: function (e) { + return m(e) || 'function' == typeof e; + }, + _cast: function (e, t) { + var r = this; + void 0 === t && (t = {}); + var A = h.default.prototype._cast.call(this, e, t); + if (void 0 === A) return this.default(); + if (!this._typeCheck(A)) return A; + var n = this.fields, + o = !0 === this._option('stripUnknown', t), + a = this._nodes.concat( + Object.keys(A).filter(function (e) { + return -1 === r._nodes.indexOf(e); + }) + ), + c = {}, + g = (0, i.default)({}, t, { parent: c, __validating: !1 }), + l = !1; + return ( + a.forEach(function (e) { + var r = n[e], + i = (0, s.default)(A, e); + if (r) { + var a, + u = r._options && r._options.strict; + if ( + ((g.path = (0, I.default)(y(), t.path, e)), + (g.value = A[e]), + !0 === (r = r.resolve(g))._strip) + ) + return void (l = l || e in A); + void 0 !== + (a = t.__validating && u ? A[e] : r.cast(A[e], g)) && + (c[e] = a); + } else i && !o && (c[e] = A[e]); + c[e] !== A[e] && (l = !0); + }), + l ? c : A + ); + }, + _validate: function (e, t) { + var r, + A, + n = this; + void 0 === t && (t = {}); + var o = t.sync, + s = [], + a = null != t.originalValue ? t.originalValue : e; + return ( + (r = this._option('abortEarly', t)), + (A = this._option('recursive', t)), + (t = (0, i.default)({}, t, { + __validating: !0, + originalValue: a, + })), + h.default.prototype._validate + .call(this, e, t) + .catch((0, E.propagateErrors)(r, s)) + .then(function (e) { + if (!A || !m(e)) { + if (s.length) throw s[0]; + return e; + } + a = a || e; + var c = n._nodes.map(function (r) { + var A = (0, I.default)(B(), t.path, r), + o = n.fields[r], + s = (0, i.default)({}, t, { + path: A, + parent: e, + originalValue: a[r], + }); + return o && o.validate + ? ((s.strict = !0), o.validate(e[r], s)) + : Promise.resolve(!0); + }); + return (0, + E.default)({ sync: o, validations: c, value: e, errors: s, endEarly: r, path: t.path, sort: (0, C.default)(n.fields) }); + }) + ); + }, + concat: function (e) { + var t = h.default.prototype.concat.call(this, e); + return (t._nodes = (0, d.default)(t.fields, t._excludedEdges)), t; + }, + shape: function (e, t) { + void 0 === t && (t = []); + var r = this.clone(), + A = (0, i.default)(r.fields, e); + if (((r.fields = A), t.length)) { + Array.isArray(t[0]) || (t = [t]); + var n = t.map(function (e) { + return e[0] + '-' + e[1]; + }); + r._excludedEdges = r._excludedEdges.concat(n); + } + return (r._nodes = (0, d.default)(A, r._excludedEdges)), r; + }, + from: function (e, t, r) { + var A = (0, u.getter)(e, !0); + return this.transform(function (n) { + if (null == n) return n; + var o = n; + return ( + (0, s.default)(n, e) && + ((o = (0, i.default)({}, n)), + r || delete o[e], + (o[t] = A(n))), + o + ); + }); + }, + noUnknown: function (e, t) { + void 0 === e && (e = !0), + void 0 === t && (t = p.object.noUnknown), + 'string' == typeof e && ((t = e), (e = !0)); + var r = this.test({ + name: 'noUnknown', + exclusive: !0, + message: t, + test: function (t) { + return ( + null == t || + !e || + 0 === + (function (e, t) { + var r = Object.keys(e.fields); + return Object.keys(t).filter(function (e) { + return -1 === r.indexOf(e); + }); + })(this.schema, t).length + ); + }, + }); + return (r._options.stripUnknown = e), r; + }, + unknown: function (e, t) { + return ( + void 0 === e && (e = !0), + void 0 === t && (t = p.object.noUnknown), + this.noUnknown(!e, t) + ); + }, + transformKeys: function (e) { + return this.transform(function (t) { + return ( + t && + (0, g.default)(t, function (t, r) { + return e(r); + }) + ); + }); + }, + camelCase: function () { + return this.transformKeys(c.default); + }, + snakeCase: function () { + return this.transformKeys(a.default); + }, + constantCase: function () { + return this.transformKeys(function (e) { + return (0, a.default)(e).toUpperCase(); + }); + }, + describe: function () { + var e = h.default.prototype.describe.call(this); + return ( + (e.fields = (0, l.default)(this.fields, function (e) { + return e.describe(); + })), + e + ); + }, + }), + (e.exports = t.default); + }, + 24280: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.default = function (e) { + Object.keys(e).forEach(function (t) { + Object.keys(e[t]).forEach(function (r) { + n.default[t][r] = e[t][r]; + }); + }); + }); + var n = A(r(63802)); + e.exports = t.default; + }, + 45167: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.default = l); + var n = A(r(31490)), + o = A(r(16434)), + i = r(63802), + s = A(r(71665)), + a = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i, + c = /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i, + g = function (e) { + return (0, s.default)(e) || e === e.trim(); + }; + function l() { + var e = this; + if (!(this instanceof l)) return new l(); + o.default.call(this, { type: 'string' }), + this.withMutation(function () { + e.transform(function (e) { + return this.isType(e) + ? e + : null != e && e.toString + ? e.toString() + : e; + }); + }); + } + (0, n.default)(l, o.default, { + _typeCheck: function (e) { + return ( + e instanceof String && (e = e.valueOf()), 'string' == typeof e + ); + }, + _isPresent: function (e) { + return o.default.prototype._cast.call(this, e) && e.length > 0; + }, + length: function (e, t) { + return ( + void 0 === t && (t = i.string.length), + this.test({ + message: t, + name: 'length', + exclusive: !0, + params: { length: e }, + test: function (t) { + return (0, s.default)(t) || t.length === this.resolve(e); + }, + }) + ); + }, + min: function (e, t) { + return ( + void 0 === t && (t = i.string.min), + this.test({ + message: t, + name: 'min', + exclusive: !0, + params: { min: e }, + test: function (t) { + return (0, s.default)(t) || t.length >= this.resolve(e); + }, + }) + ); + }, + max: function (e, t) { + return ( + void 0 === t && (t = i.string.max), + this.test({ + name: 'max', + exclusive: !0, + message: t, + params: { max: e }, + test: function (t) { + return (0, s.default)(t) || t.length <= this.resolve(e); + }, + }) + ); + }, + matches: function (e, t) { + var r, + A = !1; + return ( + t && + (t.message || t.hasOwnProperty('excludeEmptyString') + ? ((A = t.excludeEmptyString), (r = t.message)) + : (r = t)), + this.test({ + message: r || i.string.matches, + params: { regex: e }, + test: function (t) { + return (0, s.default)(t) || ('' === t && A) || e.test(t); + }, + }) + ); + }, + email: function (e) { + return ( + void 0 === e && (e = i.string.email), + this.matches(a, { message: e, excludeEmptyString: !0 }) + ); + }, + url: function (e) { + return ( + void 0 === e && (e = i.string.url), + this.matches(c, { message: e, excludeEmptyString: !0 }) + ); + }, + ensure: function () { + return this.default('').transform(function (e) { + return null === e ? '' : e; + }); + }, + trim: function (e) { + return ( + void 0 === e && (e = i.string.trim), + this.transform(function (e) { + return null != e ? e.trim() : e; + }).test({ message: e, name: 'trim', test: g }) + ); + }, + lowercase: function (e) { + return ( + void 0 === e && (e = i.string.lowercase), + this.transform(function (e) { + return (0, s.default)(e) ? e : e.toLowerCase(); + }).test({ + message: e, + name: 'string_case', + exclusive: !0, + test: function (e) { + return (0, s.default)(e) || e === e.toLowerCase(); + }, + }) + ); + }, + uppercase: function (e) { + return ( + void 0 === e && (e = i.string.uppercase), + this.transform(function (e) { + return (0, s.default)(e) ? e : e.toUpperCase(); + }).test({ + message: e, + name: 'string_case', + exclusive: !0, + test: function (e) { + return (0, s.default)(e) || e === e.toUpperCase(); + }, + }) + ); + }, + }), + (e.exports = t.default); + }, + 54107: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.createErrorFactory = l), + (t.default = function (e) { + var t = e.name, + r = e.message, + A = e.test, + i = e.params; + function g(e) { + var g = e.value, + u = e.path, + h = e.label, + p = e.options, + d = e.originalValue, + C = e.sync, + f = (0, n.default)(e, [ + 'value', + 'path', + 'label', + 'options', + 'originalValue', + 'sync', + ]), + I = p.parent, + E = function (e) { + return a.default.isRef(e) + ? e.getValue({ value: g, parent: I, context: p.context }) + : e; + }, + B = l({ + message: r, + path: u, + value: g, + originalValue: d, + params: i, + label: h, + resolve: E, + name: t, + }), + y = (0, o.default)( + { + path: u, + parent: I, + type: t, + createError: B, + resolve: E, + options: p, + }, + f + ); + return (function (e, t, r, A) { + var n = e.call(t, r); + if (!A) return Promise.resolve(n); + if ( + ((o = n), + o && + 'function' == typeof o.then && + 'function' == typeof o.catch) + ) + throw new Error( + 'Validation test of type: "' + + t.type + + '" returned a Promise during a synchronous validate. This test will finish after the validate call has returned' + ); + var o; + return c.SynchronousPromise.resolve(n); + })(A, y, g, C).then(function (e) { + if (s.default.isError(e)) throw e; + if (!e) throw B(); + }); + } + return (g.OPTIONS = e), g; + }); + var n = A(r(74943)), + o = A(r(72912)), + i = A(r(89612)), + s = A(r(40828)), + a = A(r(95814)), + c = r(93255), + g = s.default.formatError; + function l(e) { + var t = e.value, + r = e.label, + A = e.resolve, + a = e.originalValue, + c = (0, n.default)(e, [ + 'value', + 'label', + 'resolve', + 'originalValue', + ]); + return function (e) { + var n = void 0 === e ? {} : e, + l = n.path, + u = void 0 === l ? c.path : l, + h = n.message, + p = void 0 === h ? c.message : h, + d = n.type, + C = void 0 === d ? c.name : d, + f = n.params; + return ( + (f = (0, o.default)( + { path: u, value: t, originalValue: a, label: r }, + (function (e, t, r) { + return (0, i.default)((0, o.default)({}, e, t), r); + })(c.params, f, A) + )), + (0, o.default)(new s.default(g(p, f), t, u, C), { params: f }) + ); + }; + } + }, + 31490: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.default = function (e, t, r) { + (e.prototype = Object.create(t.prototype, { + constructor: { + value: e, + enumerable: !1, + writable: !0, + configurable: !0, + }, + })), + (0, n.default)(e.prototype, r); + }); + var n = A(r(72912)); + e.exports = t.default; + }, + 71665: (e, t) => { + 'use strict'; + (t.__esModule = !0), (t.default = void 0); + (t.default = function (e) { + return null == e; + }), + (e.exports = t.default); + }, + 11050: (e, t) => { + 'use strict'; + (t.__esModule = !0), (t.default = void 0); + (t.default = function (e) { + return e && e.__isYupSchema__; + }), + (e.exports = t.default); + }, + 76813: (e, t) => { + 'use strict'; + (t.__esModule = !0), + (t.default = function (e) { + var t, + A, + n = [1, 4, 5, 6, 7, 10, 11], + o = 0; + if ((A = r.exec(e))) { + for (var i, s = 0; (i = n[s]); ++s) A[i] = +A[i] || 0; + (A[2] = (+A[2] || 1) - 1), + (A[3] = +A[3] || 1), + (A[7] = A[7] ? String(A[7]).substr(0, 3) : 0), + (void 0 !== A[8] && '' !== A[8]) || + (void 0 !== A[9] && '' !== A[9]) + ? ('Z' !== A[8] && + void 0 !== A[9] && + ((o = 60 * A[10] + A[11]), '+' === A[9] && (o = 0 - o)), + (t = Date.UTC( + A[1], + A[2], + A[3], + A[4], + A[5] + o, + A[6], + A[7] + ))) + : (t = +new Date(A[1], A[2], A[3], A[4], A[5], A[6], A[7])); + } else t = Date.parse ? Date.parse(e) : NaN; + return t; + }); + var r = /^(\d{4}|[+\-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,\.](\d{1,}))?)?(?:(Z)|([+\-])(\d{2})(?::?(\d{2}))?)?)?$/; + e.exports = t.default; + }, + 7045: (e, t) => { + 'use strict'; + (t.__esModule = !0), + (t.default = function (e) { + for ( + var t = arguments.length, r = new Array(t > 1 ? t - 1 : 0), A = 1; + A < t; + A++ + ) + r[A - 1] = arguments[A]; + var n = e.reduce(function (e, t) { + var A = r.shift(); + return e + (null == A ? '' : A) + t; + }); + return n.replace(/^\./, ''); + }), + (e.exports = t.default); + }, + 22808: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.default = function e(t, r) { + for (var A in r) + if ((0, n.default)(r, A)) { + var s = r[A], + a = t[A]; + if (void 0 === a) t[A] = s; + else { + if (a === s) continue; + (0, o.default)(a) + ? (0, o.default)(s) && (t[A] = s.concat(a)) + : i(a) + ? i(s) && (t[A] = e(a, s)) + : Array.isArray(a) && + Array.isArray(s) && + (t[A] = s.concat(a)); + } + } + return t; + }); + var n = A(r(15215)), + o = A(r(11050)), + i = function (e) { + return '[object Object]' === Object.prototype.toString.call(e); + }; + e.exports = t.default; + }, + 21043: (e, t) => { + 'use strict'; + (t.__esModule = !0), + (t.default = function (e, t) { + var r = s(e, t); + return null !== r + ? r + : JSON.stringify( + e, + function (e, r) { + var A = s(this[e], t); + return null !== A ? A : r; + }, + 2 + ); + }); + var r = Object.prototype.toString, + A = Error.prototype.toString, + n = RegExp.prototype.toString, + o = + 'undefined' != typeof Symbol + ? Symbol.prototype.toString + : function () { + return ''; + }, + i = /^Symbol\((.*)\)(.*)$/; + function s(e, t) { + if ((void 0 === t && (t = !1), null == e || !0 === e || !1 === e)) + return '' + e; + var s = typeof e; + if ('number' === s) + return (function (e) { + return e != +e ? 'NaN' : 0 === e && 1 / e < 0 ? '-0' : '' + e; + })(e); + if ('string' === s) return t ? '"' + e + '"' : e; + if ('function' === s) + return '[Function ' + (e.name || 'anonymous') + ']'; + if ('symbol' === s) return o.call(e).replace(i, 'Symbol($1)'); + var a = r.call(e).slice(8, -1); + return 'Date' === a + ? isNaN(e.getTime()) + ? '' + e + : e.toISOString(e) + : 'Error' === a || e instanceof Error + ? '[' + A.call(e) + ']' + : 'RegExp' === a + ? n.call(e) + : null; + } + e.exports = t.default; + }, + 43910: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), (t.getIn = i), (t.default = void 0); + var n = r(79588), + o = A(r(15215)); + function i(e, t, r, A) { + var i, s, a; + return ( + (A = A || r), + t + ? ((0, n.forEach)(t, function (n, c, g) { + var l = c + ? (function (e) { + return e.substr(0, e.length - 1).substr(1); + })(n) + : n; + if (g || (0, o.default)(e, '_subType')) { + var u = g ? parseInt(l, 10) : 0; + if ( + ((e = e.resolve({ context: A, parent: i, value: r }) + ._subType), + r) + ) { + if (g && u >= r.length) + throw new Error( + 'Yup.reach cannot resolve an array item at index: ' + + n + + ', in the path: ' + + t + + '. because there is no value at that index. ' + ); + r = r[u]; + } + } + if (!g) { + if ( + ((e = e.resolve({ context: A, parent: i, value: r })), + !(0, o.default)(e, 'fields') || + !(0, o.default)(e.fields, l)) + ) + throw new Error( + 'The schema does not contain the path: ' + + t + + '. (failed at: ' + + a + + ' which is a type: "' + + e._type + + '") ' + ); + (e = e.fields[l]), + (i = r), + (r = r && r[l]), + (s = l), + (a = c ? '[' + n + ']' : '.' + n); + } + }), + { schema: e, parent: i, parentPath: s }) + : { parent: i, parentPath: t, schema: e } + ); + } + var s = function (e, t, r, A) { + return i(e, t, r, A).schema; + }; + t.default = s; + }, + 80180: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.propagateErrors = function (e, t) { + return e + ? null + : function (e) { + return t.push(e), e.value; + }; + }), + (t.settled = a), + (t.collectErrors = c), + (t.default = function (e) { + var t = e.endEarly, + r = (0, n.default)(e, ['endEarly']); + return t + ? (function (e, t, r) { + return s(r) + .all(e) + .catch(function (e) { + throw ('ValidationError' === e.name && (e.value = t), e); + }) + .then(function () { + return t; + }); + })(r.validations, r.value, r.sync) + : c(r); + }); + var n = A(r(74943)), + o = r(93255), + i = A(r(40828)), + s = function (e) { + return e ? o.SynchronousPromise : Promise; + }; + function a(e, t) { + var r = s(t); + return r.all( + e.map(function (e) { + return r.resolve(e).then( + function (e) { + return { fulfilled: !0, value: e }; + }, + function (e) { + return { fulfilled: !1, value: e }; + } + ); + }) + ); + } + function c(e) { + var t = e.validations, + r = e.value, + A = e.path, + n = e.sync, + o = e.errors, + s = e.sort; + return ( + (o = (function (e) { + return ( + void 0 === e && (e = []), + e.inner && e.inner.length ? e.inner : [].concat(e) + ); + })(o)), + a(t, n).then(function (e) { + var t = e + .filter(function (e) { + return !e.fulfilled; + }) + .reduce(function (e, t) { + var r = t.value; + if (!i.default.isError(r)) throw r; + return e.concat(r); + }, []); + if ((s && t.sort(s), (o = t.concat(o)).length)) + throw new i.default(o, r, A); + return r; + }) + ); + } + }, + 23316: (e, t) => { + 'use strict'; + function r(e, t) { + var r = 1 / 0; + return ( + e.some(function (e, A) { + if (-1 !== t.path.indexOf(e)) return (r = A), !0; + }), + r + ); + } + (t.__esModule = !0), + (t.default = function (e) { + var t = Object.keys(e); + return function (e, A) { + return r(t, e) - r(t, A); + }; + }), + (e.exports = t.default); + }, + 18417: (e, t, r) => { + 'use strict'; + var A = r(60087); + (t.__esModule = !0), + (t.default = function (e, t) { + void 0 === t && (t = []); + var r = [], + A = []; + function c(e, n) { + var o = (0, i.split)(e)[0]; + ~A.indexOf(o) || A.push(o), + ~t.indexOf(n + '-' + o) || r.push([n, o]); + } + for (var g in e) + if ((0, n.default)(e, g)) { + var l = e[g]; + ~A.indexOf(g) || A.push(g), + s.default.isRef(l) && l.isSibling + ? c(l.path, g) + : (0, a.default)(l) && + l._deps && + l._deps.forEach(function (e) { + return c(e, g); + }); + } + return o.default.array(A, r).reverse(); + }); + var n = A(r(15215)), + o = A(r(75158)), + i = r(79588), + s = A(r(95814)), + a = A(r(11050)); + e.exports = t.default; + }, + 60306: (e) => { + 'use strict'; + e.exports = JSON.parse( + '{"name":"@yarnpkg/cli","version":"2.4.1","license":"BSD-2-Clause","main":"./sources/index.ts","dependencies":{"@yarnpkg/core":"workspace:^2.4.0","@yarnpkg/fslib":"workspace:^2.4.0","@yarnpkg/libzip":"workspace:^2.2.1","@yarnpkg/parsers":"workspace:^2.3.0","@yarnpkg/plugin-compat":"workspace:^2.2.1","@yarnpkg/plugin-dlx":"workspace:^2.1.4","@yarnpkg/plugin-essentials":"workspace:^2.4.0","@yarnpkg/plugin-file":"workspace:^2.2.0","@yarnpkg/plugin-git":"workspace:^2.3.0","@yarnpkg/plugin-github":"workspace:^2.1.2","@yarnpkg/plugin-http":"workspace:^2.1.2","@yarnpkg/plugin-init":"workspace:^2.2.2","@yarnpkg/plugin-link":"workspace:^2.1.1","@yarnpkg/plugin-node-modules":"workspace:^2.3.0","@yarnpkg/plugin-npm":"workspace:^2.4.0","@yarnpkg/plugin-npm-cli":"workspace:^2.3.0","@yarnpkg/plugin-pack":"workspace:^2.2.3","@yarnpkg/plugin-patch":"workspace:^2.1.2","@yarnpkg/plugin-pnp":"workspace:^2.4.0","@yarnpkg/shell":"workspace:^2.4.1","chalk":"^3.0.0","ci-info":"^2.0.0","clipanion":"^2.6.2","fromentries":"^1.2.0","semver":"^7.1.2","tslib":"^1.13.0","yup":"^0.27.0"},"devDependencies":{"@types/ci-info":"^2","@types/yup":"0.26.12","@yarnpkg/builder":"workspace:^2.1.3","@yarnpkg/monorepo":"workspace:0.0.0","@yarnpkg/pnpify":"workspace:^2.4.0","micromatch":"^4.0.2","typescript":"4.1.0-beta"},"peerDependencies":{"@yarnpkg/core":"^2.4.0"},"scripts":{"postpack":"rm -rf lib","prepack":"run build:compile \\"$(pwd)\\"","build:cli+hook":"run build:pnp:hook && builder build bundle","build:cli":"builder build bundle","run:cli":"builder run","update-local":"run build:cli --no-git-hash && rsync -a --delete bundles/ bin/"},"publishConfig":{"main":"./lib/index.js","types":"./lib/index.d.ts","bin":null},"files":["/lib/**/*","!/lib/pluginConfiguration.*","!/lib/cli.*"],"@yarnpkg/builder":{"bundles":{"standard":["@yarnpkg/plugin-essentials","@yarnpkg/plugin-compat","@yarnpkg/plugin-dlx","@yarnpkg/plugin-file","@yarnpkg/plugin-git","@yarnpkg/plugin-github","@yarnpkg/plugin-http","@yarnpkg/plugin-init","@yarnpkg/plugin-link","@yarnpkg/plugin-node-modules","@yarnpkg/plugin-npm","@yarnpkg/plugin-npm-cli","@yarnpkg/plugin-pack","@yarnpkg/plugin-patch","@yarnpkg/plugin-pnp"]}},"repository":{"type":"git","url":"ssh://git@github.com/yarnpkg/berry.git"},"engines":{"node":">=10.19.0"}}' + ); + }, + 98497: (e) => { + function t(e) { + var t = new Error("Cannot find module '" + e + "'"); + throw ((t.code = 'MODULE_NOT_FOUND'), t); + } + (t.keys = () => []), (t.resolve = t), (t.id = 98497), (e.exports = t); + }, + 32178: (e) => { + function t(e) { + var t = new Error("Cannot find module '" + e + "'"); + throw ((t.code = 'MODULE_NOT_FOUND'), t); + } + (t.keys = () => []), (t.resolve = t), (t.id = 32178), (e.exports = t); + }, + 3368: (e, t, r) => { + var A, + n = Object.assign({}, r(35747)), + o = void 0 !== o ? o : {}, + i = {}; + for (A in o) o.hasOwnProperty(A) && (i[A] = o[A]); + var s, + a, + c, + g, + l = [], + u = ''; + (u = __dirname + '/'), + (s = function (e, t) { + var A = Qe(e); + return A + ? t + ? A + : A.toString() + : (c || (c = n), + g || (g = r(85622)), + (e = g.normalize(e)), + c.readFileSync(e, t ? null : 'utf8')); + }), + (a = function (e) { + var t = s(e, !0); + return t.buffer || (t = new Uint8Array(t)), E(t.buffer), t; + }), + process.argv.length > 1 && process.argv[1].replace(/\\/g, '/'), + (l = process.argv.slice(2)), + (e.exports = o), + (o.inspect = function () { + return '[Emscripten Module object]'; + }); + var h = o.print || console.log.bind(console), + p = o.printErr || console.warn.bind(console); + for (A in i) i.hasOwnProperty(A) && (o[A] = i[A]); + (i = null), + o.arguments && (l = o.arguments), + o.thisProgram && o.thisProgram, + o.quit && o.quit; + var d, C; + o.wasmBinary && (d = o.wasmBinary), + o.noExitRuntime && o.noExitRuntime, + 'object' != typeof WebAssembly && + _('no native wasm support detected'); + var f = new WebAssembly.Table({ + initial: 31, + maximum: 31, + element: 'anyfunc', + }), + I = !1; + function E(e, t) { + e || _('Assertion failed: ' + t); + } + function B(e) { + var t = o['_' + e]; + return ( + E( + t, + 'Cannot call unknown function ' + e + ', make sure it is exported' + ), + t + ); + } + function y(e, t, r, A, n) { + var o = { + string: function (e) { + var t = 0; + if (null != e && 0 !== e) { + var r = 1 + (e.length << 2); + b(e, (t = xe(r)), r); + } + return t; + }, + array: function (e) { + var t = xe(e.length); + return ( + (function (e, t) { + N.set(e, t); + })(e, t), + t + ); + }, + }; + var i = B(e), + s = [], + a = 0; + if (A) + for (var c = 0; c < A.length; c++) { + var g = o[r[c]]; + g ? (0 === a && (a = Me()), (s[c] = g(A[c]))) : (s[c] = A[c]); + } + var l = i.apply(null, s); + return ( + (l = (function (e) { + return 'string' === t ? Q(e) : 'boolean' === t ? Boolean(e) : e; + })(l)), + 0 !== a && Re(a), + l + ); + } + var m = + 'undefined' != typeof TextDecoder ? new TextDecoder('utf8') : void 0; + function w(e, t, r) { + for (var A = t + r, n = t; e[n] && !(n >= A); ) ++n; + if (n - t > 16 && e.subarray && m) return m.decode(e.subarray(t, n)); + for (var o = ''; t < n; ) { + var i = e[t++]; + if (128 & i) { + var s = 63 & e[t++]; + if (192 != (224 & i)) { + var a = 63 & e[t++]; + if ( + (i = + 224 == (240 & i) + ? ((15 & i) << 12) | (s << 6) | a + : ((7 & i) << 18) | + (s << 12) | + (a << 6) | + (63 & e[t++])) < 65536 + ) + o += String.fromCharCode(i); + else { + var c = i - 65536; + o += String.fromCharCode( + 55296 | (c >> 10), + 56320 | (1023 & c) + ); + } + } else o += String.fromCharCode(((31 & i) << 6) | s); + } else o += String.fromCharCode(i); + } + return o; + } + function Q(e, t) { + return e ? w(F, e, t) : ''; + } + function D(e, t, r, A) { + if (!(A > 0)) return 0; + for (var n = r, o = r + A - 1, i = 0; i < e.length; ++i) { + var s = e.charCodeAt(i); + if (s >= 55296 && s <= 57343) + s = (65536 + ((1023 & s) << 10)) | (1023 & e.charCodeAt(++i)); + if (s <= 127) { + if (r >= o) break; + t[r++] = s; + } else if (s <= 2047) { + if (r + 1 >= o) break; + (t[r++] = 192 | (s >> 6)), (t[r++] = 128 | (63 & s)); + } else if (s <= 65535) { + if (r + 2 >= o) break; + (t[r++] = 224 | (s >> 12)), + (t[r++] = 128 | ((s >> 6) & 63)), + (t[r++] = 128 | (63 & s)); + } else { + if (r + 3 >= o) break; + (t[r++] = 240 | (s >> 18)), + (t[r++] = 128 | ((s >> 12) & 63)), + (t[r++] = 128 | ((s >> 6) & 63)), + (t[r++] = 128 | (63 & s)); + } + } + return (t[r] = 0), r - n; + } + function b(e, t, r) { + return D(e, F, t, r); + } + function v(e) { + for (var t = 0, r = 0; r < e.length; ++r) { + var A = e.charCodeAt(r); + A >= 55296 && + A <= 57343 && + (A = (65536 + ((1023 & A) << 10)) | (1023 & e.charCodeAt(++r))), + A <= 127 ? ++t : (t += A <= 2047 ? 2 : A <= 65535 ? 3 : 4); + } + return t; + } + function S(e) { + var t = v(e) + 1, + r = Le(t); + return r && D(e, N, r, t), r; + } + var k, N, F, K, M, R, x; + function L(e) { + (k = e), + (o.HEAP8 = N = new Int8Array(e)), + (o.HEAP16 = K = new Int16Array(e)), + (o.HEAP32 = M = new Int32Array(e)), + (o.HEAPU8 = F = new Uint8Array(e)), + (o.HEAPU16 = new Uint16Array(e)), + (o.HEAPU32 = new Uint32Array(e)), + (o.HEAPF32 = R = new Float32Array(e)), + (o.HEAPF64 = x = new Float64Array(e)); + } + var P = o.INITIAL_MEMORY || 16777216; + (C = o.wasmMemory + ? o.wasmMemory + : new WebAssembly.Memory({ initial: P / 65536, maximum: 32768 })) && + (k = C.buffer), + (P = k.byteLength), + L(k); + var O = [], + U = [], + T = [], + j = []; + var Y = Math.abs, + G = Math.ceil, + H = Math.floor, + J = Math.min, + q = 0, + z = null, + W = null; + function V(e) { + q++, o.monitorRunDependencies && o.monitorRunDependencies(q); + } + function X(e) { + if ( + (q--, + o.monitorRunDependencies && o.monitorRunDependencies(q), + 0 == q && (null !== z && (clearInterval(z), (z = null)), W)) + ) { + var t = W; + (W = null), t(); + } + } + function _(e) { + throw ( + (o.onAbort && o.onAbort(e), + p((e += '')), + (I = !0), + 1, + (e = 'abort(' + e + '). Build with -s ASSERTIONS=1 for more info.'), + new WebAssembly.RuntimeError(e)) + ); + } + (o.preloadedImages = {}), (o.preloadedAudios = {}); + function Z(e) { + return ( + (t = e), + (r = 'data:application/octet-stream;base64,'), + String.prototype.startsWith ? t.startsWith(r) : 0 === t.indexOf(r) + ); + var t, r; + } + var $, + ee, + te, + re = + 'data:application/octet-stream;base64,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'; + function Ae(e) { + for (; e.length > 0; ) { + var t = e.shift(); + if ('function' != typeof t) { + var r = t.func; + 'number' == typeof r + ? void 0 === t.arg + ? f.get(r)() + : f.get(r)(t.arg) + : r(void 0 === t.arg ? null : t.arg); + } else t(o); + } + } + function ne() { + var e = (function () { + var e = new Error(); + if (!e.stack) { + try { + throw new Error(); + } catch (t) { + e = t; + } + if (!e.stack) return '(no stack trace available)'; + } + return e.stack.toString(); + })(); + return ( + o.extraStackTrace && (e += '\n' + o.extraStackTrace()), + e.replace(/\b_Z[\w\d_]+/g, function (e) { + return e == e ? e : e + ' [' + e + ']'; + }) + ); + } + function oe(e, t) { + var r = new Date(1e3 * M[e >> 2]); + (M[t >> 2] = r.getUTCSeconds()), + (M[(t + 4) >> 2] = r.getUTCMinutes()), + (M[(t + 8) >> 2] = r.getUTCHours()), + (M[(t + 12) >> 2] = r.getUTCDate()), + (M[(t + 16) >> 2] = r.getUTCMonth()), + (M[(t + 20) >> 2] = r.getUTCFullYear() - 1900), + (M[(t + 24) >> 2] = r.getUTCDay()), + (M[(t + 36) >> 2] = 0), + (M[(t + 32) >> 2] = 0); + var A = Date.UTC(r.getUTCFullYear(), 0, 1, 0, 0, 0, 0), + n = ((r.getTime() - A) / 864e5) | 0; + return ( + (M[(t + 28) >> 2] = n), + oe.GMTString || (oe.GMTString = S('GMT')), + (M[(t + 40) >> 2] = oe.GMTString), + t + ); + } + Z(re) || (($ = re), (re = o.locateFile ? o.locateFile($, u) : u + $)), + U.push({ + func: function () { + Se(); + }, + }); + var ie = { + splitPath: function (e) { + return /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/ + .exec(e) + .slice(1); + }, + normalizeArray: function (e, t) { + for (var r = 0, A = e.length - 1; A >= 0; A--) { + var n = e[A]; + '.' === n + ? e.splice(A, 1) + : '..' === n + ? (e.splice(A, 1), r++) + : r && (e.splice(A, 1), r--); + } + if (t) for (; r; r--) e.unshift('..'); + return e; + }, + normalize: function (e) { + var t = '/' === e.charAt(0), + r = '/' === e.substr(-1); + return ( + (e = ie + .normalizeArray( + e.split('/').filter(function (e) { + return !!e; + }), + !t + ) + .join('/')) || + t || + (e = '.'), + e && r && (e += '/'), + (t ? '/' : '') + e + ); + }, + dirname: function (e) { + var t = ie.splitPath(e), + r = t[0], + A = t[1]; + return r || A ? (A && (A = A.substr(0, A.length - 1)), r + A) : '.'; + }, + basename: function (e) { + if ('/' === e) return '/'; + var t = (e = (e = ie.normalize(e)).replace(/\/$/, '')).lastIndexOf( + '/' + ); + return -1 === t ? e : e.substr(t + 1); + }, + extname: function (e) { + return ie.splitPath(e)[3]; + }, + join: function () { + var e = Array.prototype.slice.call(arguments, 0); + return ie.normalize(e.join('/')); + }, + join2: function (e, t) { + return ie.normalize(e + '/' + t); + }, + }; + function se(e) { + return (M[ke() >> 2] = e), e; + } + var ae = { + resolve: function () { + for ( + var e = '', t = !1, r = arguments.length - 1; + r >= -1 && !t; + r-- + ) { + var A = r >= 0 ? arguments[r] : pe.cwd(); + if ('string' != typeof A) + throw new TypeError( + 'Arguments to path.resolve must be strings' + ); + if (!A) return ''; + (e = A + '/' + e), (t = '/' === A.charAt(0)); + } + return ( + (t ? '/' : '') + + (e = ie + .normalizeArray( + e.split('/').filter(function (e) { + return !!e; + }), + !t + ) + .join('/')) || '.' + ); + }, + relative: function (e, t) { + function r(e) { + for (var t = 0; t < e.length && '' === e[t]; t++); + for (var r = e.length - 1; r >= 0 && '' === e[r]; r--); + return t > r ? [] : e.slice(t, r - t + 1); + } + (e = ae.resolve(e).substr(1)), (t = ae.resolve(t).substr(1)); + for ( + var A = r(e.split('/')), + n = r(t.split('/')), + o = Math.min(A.length, n.length), + i = o, + s = 0; + s < o; + s++ + ) + if (A[s] !== n[s]) { + i = s; + break; + } + var a = []; + for (s = i; s < A.length; s++) a.push('..'); + return (a = a.concat(n.slice(i))).join('/'); + }, + }, + ce = { + ttys: [], + init: function () {}, + shutdown: function () {}, + register: function (e, t) { + (ce.ttys[e] = { input: [], output: [], ops: t }), + pe.registerDevice(e, ce.stream_ops); + }, + stream_ops: { + open: function (e) { + var t = ce.ttys[e.node.rdev]; + if (!t) throw new pe.ErrnoError(43); + (e.tty = t), (e.seekable = !1); + }, + close: function (e) { + e.tty.ops.flush(e.tty); + }, + flush: function (e) { + e.tty.ops.flush(e.tty); + }, + read: function (e, t, r, A, n) { + if (!e.tty || !e.tty.ops.get_char) throw new pe.ErrnoError(60); + for (var o = 0, i = 0; i < A; i++) { + var s; + try { + s = e.tty.ops.get_char(e.tty); + } catch (e) { + throw new pe.ErrnoError(29); + } + if (void 0 === s && 0 === o) throw new pe.ErrnoError(6); + if (null == s) break; + o++, (t[r + i] = s); + } + return o && (e.node.timestamp = Date.now()), o; + }, + write: function (e, t, r, A, n) { + if (!e.tty || !e.tty.ops.put_char) throw new pe.ErrnoError(60); + try { + for (var o = 0; o < A; o++) + e.tty.ops.put_char(e.tty, t[r + o]); + } catch (e) { + throw new pe.ErrnoError(29); + } + return A && (e.node.timestamp = Date.now()), o; + }, + }, + default_tty_ops: { + get_char: function (e) { + if (!e.input.length) { + var t = null, + r = Buffer.alloc ? Buffer.alloc(256) : new Buffer(256), + A = 0; + try { + A = c.readSync(process.stdin.fd, r, 0, 256, null); + } catch (e) { + if (-1 == e.toString().indexOf('EOF')) throw e; + A = 0; + } + if (!(t = A > 0 ? r.slice(0, A).toString('utf-8') : null)) + return null; + e.input = we(t, !0); + } + return e.input.shift(); + }, + put_char: function (e, t) { + null === t || 10 === t + ? (h(w(e.output, 0)), (e.output = [])) + : 0 != t && e.output.push(t); + }, + flush: function (e) { + e.output && + e.output.length > 0 && + (h(w(e.output, 0)), (e.output = [])); + }, + }, + default_tty1_ops: { + put_char: function (e, t) { + null === t || 10 === t + ? (p(w(e.output, 0)), (e.output = [])) + : 0 != t && e.output.push(t); + }, + flush: function (e) { + e.output && + e.output.length > 0 && + (p(w(e.output, 0)), (e.output = [])); + }, + }, + }, + ge = { + ops_table: null, + mount: function (e) { + return ge.createNode(null, '/', 16895, 0); + }, + createNode: function (e, t, r, A) { + if (pe.isBlkdev(r) || pe.isFIFO(r)) throw new pe.ErrnoError(63); + ge.ops_table || + (ge.ops_table = { + dir: { + node: { + getattr: ge.node_ops.getattr, + setattr: ge.node_ops.setattr, + lookup: ge.node_ops.lookup, + mknod: ge.node_ops.mknod, + rename: ge.node_ops.rename, + unlink: ge.node_ops.unlink, + rmdir: ge.node_ops.rmdir, + readdir: ge.node_ops.readdir, + symlink: ge.node_ops.symlink, + }, + stream: { llseek: ge.stream_ops.llseek }, + }, + file: { + node: { + getattr: ge.node_ops.getattr, + setattr: ge.node_ops.setattr, + }, + stream: { + llseek: ge.stream_ops.llseek, + read: ge.stream_ops.read, + write: ge.stream_ops.write, + allocate: ge.stream_ops.allocate, + mmap: ge.stream_ops.mmap, + msync: ge.stream_ops.msync, + }, + }, + link: { + node: { + getattr: ge.node_ops.getattr, + setattr: ge.node_ops.setattr, + readlink: ge.node_ops.readlink, + }, + stream: {}, + }, + chrdev: { + node: { + getattr: ge.node_ops.getattr, + setattr: ge.node_ops.setattr, + }, + stream: pe.chrdev_stream_ops, + }, + }); + var n = pe.createNode(e, t, r, A); + return ( + pe.isDir(n.mode) + ? ((n.node_ops = ge.ops_table.dir.node), + (n.stream_ops = ge.ops_table.dir.stream), + (n.contents = {})) + : pe.isFile(n.mode) + ? ((n.node_ops = ge.ops_table.file.node), + (n.stream_ops = ge.ops_table.file.stream), + (n.usedBytes = 0), + (n.contents = null)) + : pe.isLink(n.mode) + ? ((n.node_ops = ge.ops_table.link.node), + (n.stream_ops = ge.ops_table.link.stream)) + : pe.isChrdev(n.mode) && + ((n.node_ops = ge.ops_table.chrdev.node), + (n.stream_ops = ge.ops_table.chrdev.stream)), + (n.timestamp = Date.now()), + e && (e.contents[t] = n), + n + ); + }, + getFileDataAsRegularArray: function (e) { + if (e.contents && e.contents.subarray) { + for (var t = [], r = 0; r < e.usedBytes; ++r) + t.push(e.contents[r]); + return t; + } + return e.contents; + }, + getFileDataAsTypedArray: function (e) { + return e.contents + ? e.contents.subarray + ? e.contents.subarray(0, e.usedBytes) + : new Uint8Array(e.contents) + : new Uint8Array(0); + }, + expandFileStorage: function (e, t) { + var r = e.contents ? e.contents.length : 0; + if (!(r >= t)) { + (t = Math.max(t, (r * (r < 1048576 ? 2 : 1.125)) >>> 0)), + 0 != r && (t = Math.max(t, 256)); + var A = e.contents; + (e.contents = new Uint8Array(t)), + e.usedBytes > 0 && + e.contents.set(A.subarray(0, e.usedBytes), 0); + } + }, + resizeFileStorage: function (e, t) { + if (e.usedBytes != t) { + if (0 == t) return (e.contents = null), void (e.usedBytes = 0); + if (!e.contents || e.contents.subarray) { + var r = e.contents; + return ( + (e.contents = new Uint8Array(t)), + r && + e.contents.set(r.subarray(0, Math.min(t, e.usedBytes))), + void (e.usedBytes = t) + ); + } + if ((e.contents || (e.contents = []), e.contents.length > t)) + e.contents.length = t; + else for (; e.contents.length < t; ) e.contents.push(0); + e.usedBytes = t; + } + }, + node_ops: { + getattr: function (e) { + var t = {}; + return ( + (t.dev = pe.isChrdev(e.mode) ? e.id : 1), + (t.ino = e.id), + (t.mode = e.mode), + (t.nlink = 1), + (t.uid = 0), + (t.gid = 0), + (t.rdev = e.rdev), + pe.isDir(e.mode) + ? (t.size = 4096) + : pe.isFile(e.mode) + ? (t.size = e.usedBytes) + : pe.isLink(e.mode) + ? (t.size = e.link.length) + : (t.size = 0), + (t.atime = new Date(e.timestamp)), + (t.mtime = new Date(e.timestamp)), + (t.ctime = new Date(e.timestamp)), + (t.blksize = 4096), + (t.blocks = Math.ceil(t.size / t.blksize)), + t + ); + }, + setattr: function (e, t) { + void 0 !== t.mode && (e.mode = t.mode), + void 0 !== t.timestamp && (e.timestamp = t.timestamp), + void 0 !== t.size && ge.resizeFileStorage(e, t.size); + }, + lookup: function (e, t) { + throw pe.genericErrors[44]; + }, + mknod: function (e, t, r, A) { + return ge.createNode(e, t, r, A); + }, + rename: function (e, t, r) { + if (pe.isDir(e.mode)) { + var A; + try { + A = pe.lookupNode(t, r); + } catch (e) {} + if (A) for (var n in A.contents) throw new pe.ErrnoError(55); + } + delete e.parent.contents[e.name], + (e.name = r), + (t.contents[r] = e), + (e.parent = t); + }, + unlink: function (e, t) { + delete e.contents[t]; + }, + rmdir: function (e, t) { + var r = pe.lookupNode(e, t); + for (var A in r.contents) throw new pe.ErrnoError(55); + delete e.contents[t]; + }, + readdir: function (e) { + var t = ['.', '..']; + for (var r in e.contents) + e.contents.hasOwnProperty(r) && t.push(r); + return t; + }, + symlink: function (e, t, r) { + var A = ge.createNode(e, t, 41471, 0); + return (A.link = r), A; + }, + readlink: function (e) { + if (!pe.isLink(e.mode)) throw new pe.ErrnoError(28); + return e.link; + }, + }, + stream_ops: { + read: function (e, t, r, A, n) { + var o = e.node.contents; + if (n >= e.node.usedBytes) return 0; + var i = Math.min(e.node.usedBytes - n, A); + if (i > 8 && o.subarray) t.set(o.subarray(n, n + i), r); + else for (var s = 0; s < i; s++) t[r + s] = o[n + s]; + return i; + }, + write: function (e, t, r, A, n, o) { + if ((t.buffer === N.buffer && (o = !1), !A)) return 0; + var i = e.node; + if ( + ((i.timestamp = Date.now()), + t.subarray && (!i.contents || i.contents.subarray)) + ) { + if (o) + return ( + (i.contents = t.subarray(r, r + A)), (i.usedBytes = A), A + ); + if (0 === i.usedBytes && 0 === n) + return ( + (i.contents = t.slice(r, r + A)), (i.usedBytes = A), A + ); + if (n + A <= i.usedBytes) + return i.contents.set(t.subarray(r, r + A), n), A; + } + if ( + (ge.expandFileStorage(i, n + A), + i.contents.subarray && t.subarray) + ) + i.contents.set(t.subarray(r, r + A), n); + else for (var s = 0; s < A; s++) i.contents[n + s] = t[r + s]; + return (i.usedBytes = Math.max(i.usedBytes, n + A)), A; + }, + llseek: function (e, t, r) { + var A = t; + if ( + (1 === r + ? (A += e.position) + : 2 === r && + pe.isFile(e.node.mode) && + (A += e.node.usedBytes), + A < 0) + ) + throw new pe.ErrnoError(28); + return A; + }, + allocate: function (e, t, r) { + ge.expandFileStorage(e.node, t + r), + (e.node.usedBytes = Math.max(e.node.usedBytes, t + r)); + }, + mmap: function (e, t, r, A, n, o) { + if ((E(0 === t), !pe.isFile(e.node.mode))) + throw new pe.ErrnoError(43); + var i, + s, + a = e.node.contents; + if (2 & o || a.buffer !== k) { + if ( + ((A > 0 || A + r < a.length) && + (a = a.subarray + ? a.subarray(A, A + r) + : Array.prototype.slice.call(a, A, A + r)), + (s = !0), + !(i = pe.mmapAlloc(r))) + ) + throw new pe.ErrnoError(48); + N.set(a, i); + } else (s = !1), (i = a.byteOffset); + return { ptr: i, allocated: s }; + }, + msync: function (e, t, r, A, n) { + if (!pe.isFile(e.node.mode)) throw new pe.ErrnoError(43); + if (2 & n) return 0; + ge.stream_ops.write(e, t, 0, A, r, !1); + return 0; + }, + }, + }, + le = { + EPERM: 63, + ENOENT: 44, + ESRCH: 71, + EINTR: 27, + EIO: 29, + ENXIO: 60, + E2BIG: 1, + ENOEXEC: 45, + EBADF: 8, + ECHILD: 12, + EAGAIN: 6, + EWOULDBLOCK: 6, + ENOMEM: 48, + EACCES: 2, + EFAULT: 21, + ENOTBLK: 105, + EBUSY: 10, + EEXIST: 20, + EXDEV: 75, + ENODEV: 43, + ENOTDIR: 54, + EISDIR: 31, + EINVAL: 28, + ENFILE: 41, + EMFILE: 33, + ENOTTY: 59, + ETXTBSY: 74, + EFBIG: 22, + ENOSPC: 51, + ESPIPE: 70, + EROFS: 69, + EMLINK: 34, + EPIPE: 64, + EDOM: 18, + ERANGE: 68, + ENOMSG: 49, + EIDRM: 24, + ECHRNG: 106, + EL2NSYNC: 156, + EL3HLT: 107, + EL3RST: 108, + ELNRNG: 109, + EUNATCH: 110, + ENOCSI: 111, + EL2HLT: 112, + EDEADLK: 16, + ENOLCK: 46, + EBADE: 113, + EBADR: 114, + EXFULL: 115, + ENOANO: 104, + EBADRQC: 103, + EBADSLT: 102, + EDEADLOCK: 16, + EBFONT: 101, + ENOSTR: 100, + ENODATA: 116, + ETIME: 117, + ENOSR: 118, + ENONET: 119, + ENOPKG: 120, + EREMOTE: 121, + ENOLINK: 47, + EADV: 122, + ESRMNT: 123, + ECOMM: 124, + EPROTO: 65, + EMULTIHOP: 36, + EDOTDOT: 125, + EBADMSG: 9, + ENOTUNIQ: 126, + EBADFD: 127, + EREMCHG: 128, + ELIBACC: 129, + ELIBBAD: 130, + ELIBSCN: 131, + ELIBMAX: 132, + ELIBEXEC: 133, + ENOSYS: 52, + ENOTEMPTY: 55, + ENAMETOOLONG: 37, + ELOOP: 32, + EOPNOTSUPP: 138, + EPFNOSUPPORT: 139, + ECONNRESET: 15, + ENOBUFS: 42, + EAFNOSUPPORT: 5, + EPROTOTYPE: 67, + ENOTSOCK: 57, + ENOPROTOOPT: 50, + ESHUTDOWN: 140, + ECONNREFUSED: 14, + EADDRINUSE: 3, + ECONNABORTED: 13, + ENETUNREACH: 40, + ENETDOWN: 38, + ETIMEDOUT: 73, + EHOSTDOWN: 142, + EHOSTUNREACH: 23, + EINPROGRESS: 26, + EALREADY: 7, + EDESTADDRREQ: 17, + EMSGSIZE: 35, + EPROTONOSUPPORT: 66, + ESOCKTNOSUPPORT: 137, + EADDRNOTAVAIL: 4, + ENETRESET: 39, + EISCONN: 30, + ENOTCONN: 53, + ETOOMANYREFS: 141, + EUSERS: 136, + EDQUOT: 19, + ESTALE: 72, + ENOTSUP: 138, + ENOMEDIUM: 148, + EILSEQ: 25, + EOVERFLOW: 61, + ECANCELED: 11, + ENOTRECOVERABLE: 56, + EOWNERDEAD: 62, + ESTRPIPE: 135, + }, + ue = { + isWindows: !1, + staticInit: function () { + ue.isWindows = !!process.platform.match(/^win/); + var e = { fs: Ie.constants }; + e.fs && (e = e.fs), + (ue.flagsForNodeMap = { + 1024: e.O_APPEND, + 64: e.O_CREAT, + 128: e.O_EXCL, + 0: e.O_RDONLY, + 2: e.O_RDWR, + 4096: e.O_SYNC, + 512: e.O_TRUNC, + 1: e.O_WRONLY, + }); + }, + bufferFrom: function (e) { + return Buffer.alloc ? Buffer.from(e) : new Buffer(e); + }, + convertNodeCode: function (e) { + var t = e.code; + return le[t]; + }, + mount: function (e) { + return ue.createNode(null, '/', ue.getMode(e.opts.root), 0); + }, + createNode: function (e, t, r, A) { + if (!pe.isDir(r) && !pe.isFile(r) && !pe.isLink(r)) + throw new pe.ErrnoError(28); + var n = pe.createNode(e, t, r); + return ( + (n.node_ops = ue.node_ops), (n.stream_ops = ue.stream_ops), n + ); + }, + getMode: function (e) { + var t; + try { + (t = Ie.lstatSync(e)), + ue.isWindows && (t.mode = t.mode | ((292 & t.mode) >> 2)); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + return t.mode; + }, + realPath: function (e) { + for (var t = []; e.parent !== e; ) t.push(e.name), (e = e.parent); + return ( + t.push(e.mount.opts.root), t.reverse(), ie.join.apply(null, t) + ); + }, + flagsForNode: function (e) { + (e &= -2097153), (e &= -2049), (e &= -32769), (e &= -524289); + var t = 0; + for (var r in ue.flagsForNodeMap) + e & r && ((t |= ue.flagsForNodeMap[r]), (e ^= r)); + if (e) throw new pe.ErrnoError(28); + return t; + }, + node_ops: { + getattr: function (e) { + var t, + r = ue.realPath(e); + try { + t = Ie.lstatSync(r); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + return ( + ue.isWindows && !t.blksize && (t.blksize = 4096), + ue.isWindows && + !t.blocks && + (t.blocks = ((t.size + t.blksize - 1) / t.blksize) | 0), + { + dev: t.dev, + ino: t.ino, + mode: t.mode, + nlink: t.nlink, + uid: t.uid, + gid: t.gid, + rdev: t.rdev, + size: t.size, + atime: t.atime, + mtime: t.mtime, + ctime: t.ctime, + blksize: t.blksize, + blocks: t.blocks, + } + ); + }, + setattr: function (e, t) { + var r = ue.realPath(e); + try { + if ( + (void 0 !== t.mode && + (Ie.chmodSync(r, t.mode), (e.mode = t.mode)), + void 0 !== t.timestamp) + ) { + var A = new Date(t.timestamp); + Ie.utimesSync(r, A, A); + } + void 0 !== t.size && Ie.truncateSync(r, t.size); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + lookup: function (e, t) { + var r = ie.join2(ue.realPath(e), t), + A = ue.getMode(r); + return ue.createNode(e, t, A); + }, + mknod: function (e, t, r, A) { + var n = ue.createNode(e, t, r, A), + o = ue.realPath(n); + try { + pe.isDir(n.mode) + ? Ie.mkdirSync(o, n.mode) + : Ie.writeFileSync(o, '', { mode: n.mode }); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + return n; + }, + rename: function (e, t, r) { + var A = ue.realPath(e), + n = ie.join2(ue.realPath(t), r); + try { + Ie.renameSync(A, n); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + e.name = r; + }, + unlink: function (e, t) { + var r = ie.join2(ue.realPath(e), t); + try { + Ie.unlinkSync(r); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + rmdir: function (e, t) { + var r = ie.join2(ue.realPath(e), t); + try { + Ie.rmdirSync(r); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + readdir: function (e) { + var t = ue.realPath(e); + try { + return Ie.readdirSync(t); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + symlink: function (e, t, r) { + var A = ie.join2(ue.realPath(e), t); + try { + Ie.symlinkSync(r, A); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + readlink: function (e) { + var t = ue.realPath(e); + try { + return ( + (t = Ie.readlinkSync(t)), + (t = Ee.relative(Ee.resolve(e.mount.opts.root), t)) + ); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + }, + stream_ops: { + open: function (e) { + var t = ue.realPath(e.node); + try { + pe.isFile(e.node.mode) && + (e.nfd = Ie.openSync(t, ue.flagsForNode(e.flags))); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + close: function (e) { + try { + pe.isFile(e.node.mode) && e.nfd && Ie.closeSync(e.nfd); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + read: function (e, t, r, A, n) { + if (0 === A) return 0; + try { + return Ie.readSync(e.nfd, ue.bufferFrom(t.buffer), r, A, n); + } catch (e) { + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + write: function (e, t, r, A, n) { + try { + return Ie.writeSync(e.nfd, ue.bufferFrom(t.buffer), r, A, n); + } catch (e) { + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + }, + llseek: function (e, t, r) { + var A = t; + if (1 === r) A += e.position; + else if (2 === r && pe.isFile(e.node.mode)) + try { + A += Ie.fstatSync(e.nfd).size; + } catch (e) { + throw new pe.ErrnoError(ue.convertNodeCode(e)); + } + if (A < 0) throw new pe.ErrnoError(28); + return A; + }, + mmap: function (e, t, r, A, n, o) { + if ((E(0 === t), !pe.isFile(e.node.mode))) + throw new pe.ErrnoError(43); + var i = pe.mmapAlloc(r); + return ( + ue.stream_ops.read(e, N, i, r, A), { ptr: i, allocated: !0 } + ); + }, + msync: function (e, t, r, A, n) { + if (!pe.isFile(e.node.mode)) throw new pe.ErrnoError(43); + if (2 & n) return 0; + ue.stream_ops.write(e, t, 0, A, r, !1); + return 0; + }, + }, + }, + he = { + lookupPath: function (e) { + return { path: e, node: { mode: ue.getMode(e) } }; + }, + createStandardStreams: function () { + pe.streams[0] = { + fd: 0, + nfd: 0, + position: 0, + path: '', + flags: 0, + tty: !0, + seekable: !1, + }; + for (var e = 1; e < 3; e++) + pe.streams[e] = { + fd: e, + nfd: e, + position: 0, + path: '', + flags: 577, + tty: !0, + seekable: !1, + }; + }, + cwd: function () { + return process.cwd(); + }, + chdir: function () { + process.chdir.apply(void 0, arguments); + }, + mknod: function (e, t) { + pe.isDir(e) + ? Ie.mkdirSync(e, t) + : Ie.writeFileSync(e, '', { mode: t }); + }, + mkdir: function () { + Ie.mkdirSync.apply(void 0, arguments); + }, + symlink: function () { + Ie.symlinkSync.apply(void 0, arguments); + }, + rename: function () { + Ie.renameSync.apply(void 0, arguments); + }, + rmdir: function () { + Ie.rmdirSync.apply(void 0, arguments); + }, + readdir: function () { + Ie.readdirSync.apply(void 0, arguments); + }, + unlink: function () { + Ie.unlinkSync.apply(void 0, arguments); + }, + readlink: function () { + return Ie.readlinkSync.apply(void 0, arguments); + }, + stat: function () { + return Ie.statSync.apply(void 0, arguments); + }, + lstat: function () { + return Ie.lstatSync.apply(void 0, arguments); + }, + chmod: function () { + Ie.chmodSync.apply(void 0, arguments); + }, + fchmod: function () { + Ie.fchmodSync.apply(void 0, arguments); + }, + chown: function () { + Ie.chownSync.apply(void 0, arguments); + }, + fchown: function () { + Ie.fchownSync.apply(void 0, arguments); + }, + truncate: function () { + Ie.truncateSync.apply(void 0, arguments); + }, + ftruncate: function () { + Ie.ftruncateSync.apply(void 0, arguments); + }, + utime: function () { + Ie.utimesSync.apply(void 0, arguments); + }, + open: function (e, t, r, A) { + 'string' == typeof t && (t = ye.modeStringToFlags(t)); + var n = Ie.openSync(e, ue.flagsForNode(t), r), + o = null != A ? A : pe.nextfd(n), + i = { + fd: o, + nfd: n, + position: 0, + path: e, + flags: t, + seekable: !0, + }; + return (pe.streams[o] = i), i; + }, + close: function (e) { + e.stream_ops || Ie.closeSync(e.nfd), pe.closeStream(e.fd); + }, + llseek: function (e, t, r) { + if (e.stream_ops) return ye.llseek(e, t, r); + var A = t; + if (1 === r) A += e.position; + else if (2 === r) A += Ie.fstatSync(e.nfd).size; + else if (0 !== r) throw new pe.ErrnoError(le.EINVAL); + if (A < 0) throw new pe.ErrnoError(le.EINVAL); + return (e.position = A), A; + }, + read: function (e, t, r, A, n) { + if (e.stream_ops) return ye.read(e, t, r, A, n); + var o = void 0 !== n; + !o && e.seekable && (n = e.position); + var i = Ie.readSync(e.nfd, ue.bufferFrom(t.buffer), r, A, n); + return o || (e.position += i), i; + }, + write: function (e, t, r, A, n) { + if (e.stream_ops) return ye.write(e, t, r, A, n); + 1024 & e.flags && pe.llseek(e, 0, 2); + var o = void 0 !== n; + !o && e.seekable && (n = e.position); + var i = Ie.writeSync(e.nfd, ue.bufferFrom(t.buffer), r, A, n); + return o || (e.position += i), i; + }, + allocate: function () { + throw new pe.ErrnoError(le.EOPNOTSUPP); + }, + mmap: function () { + throw new pe.ErrnoError(le.ENODEV); + }, + msync: function () { + return 0; + }, + munmap: function () { + return 0; + }, + ioctl: function () { + throw new pe.ErrnoError(le.ENOTTY); + }, + }, + pe = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: '/', + initialized: !1, + ignorePermissions: !0, + trackingDelegate: {}, + tracking: { openFlags: { READ: 1, WRITE: 2 } }, + ErrnoError: null, + genericErrors: {}, + filesystems: null, + syncFSRequests: 0, + handleFSError: function (e) { + if (!(e instanceof pe.ErrnoError)) throw e + ' : ' + ne(); + return se(e.errno); + }, + lookupPath: function (e, t) { + if (((t = t || {}), !(e = ae.resolve(pe.cwd(), e)))) + return { path: '', node: null }; + var r = { follow_mount: !0, recurse_count: 0 }; + for (var A in r) void 0 === t[A] && (t[A] = r[A]); + if (t.recurse_count > 8) throw new pe.ErrnoError(32); + for ( + var n = ie.normalizeArray( + e.split('/').filter(function (e) { + return !!e; + }), + !1 + ), + o = pe.root, + i = '/', + s = 0; + s < n.length; + s++ + ) { + var a = s === n.length - 1; + if (a && t.parent) break; + if ( + ((o = pe.lookupNode(o, n[s])), + (i = ie.join2(i, n[s])), + pe.isMountpoint(o) && + (!a || (a && t.follow_mount)) && + (o = o.mounted.root), + !a || t.follow) + ) + for (var c = 0; pe.isLink(o.mode); ) { + var g = pe.readlink(i); + if ( + ((i = ae.resolve(ie.dirname(i), g)), + (o = pe.lookupPath(i, { recurse_count: t.recurse_count }) + .node), + c++ > 40) + ) + throw new pe.ErrnoError(32); + } + } + return { path: i, node: o }; + }, + getPath: function (e) { + for (var t; ; ) { + if (pe.isRoot(e)) { + var r = e.mount.mountpoint; + return t + ? '/' !== r[r.length - 1] + ? r + '/' + t + : r + t + : r; + } + (t = t ? e.name + '/' + t : e.name), (e = e.parent); + } + }, + hashName: function (e, t) { + for (var r = 0, A = 0; A < t.length; A++) + r = ((r << 5) - r + t.charCodeAt(A)) | 0; + return ((e + r) >>> 0) % pe.nameTable.length; + }, + hashAddNode: function (e) { + var t = pe.hashName(e.parent.id, e.name); + (e.name_next = pe.nameTable[t]), (pe.nameTable[t] = e); + }, + hashRemoveNode: function (e) { + var t = pe.hashName(e.parent.id, e.name); + if (pe.nameTable[t] === e) pe.nameTable[t] = e.name_next; + else + for (var r = pe.nameTable[t]; r; ) { + if (r.name_next === e) { + r.name_next = e.name_next; + break; + } + r = r.name_next; + } + }, + lookupNode: function (e, t) { + var r = pe.mayLookup(e); + if (r) throw new pe.ErrnoError(r, e); + for ( + var A = pe.hashName(e.id, t), n = pe.nameTable[A]; + n; + n = n.name_next + ) { + var o = n.name; + if (n.parent.id === e.id && o === t) return n; + } + return pe.lookup(e, t); + }, + createNode: function (e, t, r, A) { + var n = new pe.FSNode(e, t, r, A); + return pe.hashAddNode(n), n; + }, + destroyNode: function (e) { + pe.hashRemoveNode(e); + }, + isRoot: function (e) { + return e === e.parent; + }, + isMountpoint: function (e) { + return !!e.mounted; + }, + isFile: function (e) { + return 32768 == (61440 & e); + }, + isDir: function (e) { + return 16384 == (61440 & e); + }, + isLink: function (e) { + return 40960 == (61440 & e); + }, + isChrdev: function (e) { + return 8192 == (61440 & e); + }, + isBlkdev: function (e) { + return 24576 == (61440 & e); + }, + isFIFO: function (e) { + return 4096 == (61440 & e); + }, + isSocket: function (e) { + return 49152 == (49152 & e); + }, + flagModes: { + r: 0, + rs: 1052672, + 'r+': 2, + w: 577, + wx: 705, + xw: 705, + 'w+': 578, + 'wx+': 706, + 'xw+': 706, + a: 1089, + ax: 1217, + xa: 1217, + 'a+': 1090, + 'ax+': 1218, + 'xa+': 1218, + }, + modeStringToFlags: function (e) { + var t = pe.flagModes[e]; + if (void 0 === t) throw new Error('Unknown file open mode: ' + e); + return t; + }, + flagsToPermissionString: function (e) { + var t = ['r', 'w', 'rw'][3 & e]; + return 512 & e && (t += 'w'), t; + }, + nodePermissions: function (e, t) { + return pe.ignorePermissions || + ((-1 === t.indexOf('r') || 292 & e.mode) && + (-1 === t.indexOf('w') || 146 & e.mode) && + (-1 === t.indexOf('x') || 73 & e.mode)) + ? 0 + : 2; + }, + mayLookup: function (e) { + var t = pe.nodePermissions(e, 'x'); + return t || (e.node_ops.lookup ? 0 : 2); + }, + mayCreate: function (e, t) { + try { + pe.lookupNode(e, t); + return 20; + } catch (e) {} + return pe.nodePermissions(e, 'wx'); + }, + mayDelete: function (e, t, r) { + var A; + try { + A = pe.lookupNode(e, t); + } catch (e) { + return e.errno; + } + var n = pe.nodePermissions(e, 'wx'); + if (n) return n; + if (r) { + if (!pe.isDir(A.mode)) return 54; + if (pe.isRoot(A) || pe.getPath(A) === pe.cwd()) return 10; + } else if (pe.isDir(A.mode)) return 31; + return 0; + }, + mayOpen: function (e, t) { + return e + ? pe.isLink(e.mode) + ? 32 + : pe.isDir(e.mode) && + ('r' !== pe.flagsToPermissionString(t) || 512 & t) + ? 31 + : pe.nodePermissions(e, pe.flagsToPermissionString(t)) + : 44; + }, + MAX_OPEN_FDS: 4096, + nextfd: function (e, t) { + (e = e || 0), (t = t || pe.MAX_OPEN_FDS); + for (var r = e; r <= t; r++) if (!pe.streams[r]) return r; + throw new pe.ErrnoError(33); + }, + getStream: function (e) { + return pe.streams[e]; + }, + createStream: function (e, t, r) { + pe.FSStream || + ((pe.FSStream = function () {}), + (pe.FSStream.prototype = { + object: { + get: function () { + return this.node; + }, + set: function (e) { + this.node = e; + }, + }, + isRead: { + get: function () { + return 1 != (2097155 & this.flags); + }, + }, + isWrite: { + get: function () { + return 0 != (2097155 & this.flags); + }, + }, + isAppend: { + get: function () { + return 1024 & this.flags; + }, + }, + })); + var A = new pe.FSStream(); + for (var n in e) A[n] = e[n]; + e = A; + var o = pe.nextfd(t, r); + return (e.fd = o), (pe.streams[o] = e), e; + }, + closeStream: function (e) { + pe.streams[e] = null; + }, + chrdev_stream_ops: { + open: function (e) { + var t = pe.getDevice(e.node.rdev); + (e.stream_ops = t.stream_ops), + e.stream_ops.open && e.stream_ops.open(e); + }, + llseek: function () { + throw new pe.ErrnoError(70); + }, + }, + major: function (e) { + return e >> 8; + }, + minor: function (e) { + return 255 & e; + }, + makedev: function (e, t) { + return (e << 8) | t; + }, + registerDevice: function (e, t) { + pe.devices[e] = { stream_ops: t }; + }, + getDevice: function (e) { + return pe.devices[e]; + }, + getMounts: function (e) { + for (var t = [], r = [e]; r.length; ) { + var A = r.pop(); + t.push(A), r.push.apply(r, A.mounts); + } + return t; + }, + syncfs: function (e, t) { + 'function' == typeof e && ((t = e), (e = !1)), + pe.syncFSRequests++, + pe.syncFSRequests > 1 && + p( + 'warning: ' + + pe.syncFSRequests + + ' FS.syncfs operations in flight at once, probably just doing extra work' + ); + var r = pe.getMounts(pe.root.mount), + A = 0; + function n(e) { + return pe.syncFSRequests--, t(e); + } + function o(e) { + if (e) return o.errored ? void 0 : ((o.errored = !0), n(e)); + ++A >= r.length && n(null); + } + r.forEach(function (t) { + if (!t.type.syncfs) return o(null); + t.type.syncfs(t, e, o); + }); + }, + mount: function (e, t, r) { + var A, + n = '/' === r, + o = !r; + if (n && pe.root) throw new pe.ErrnoError(10); + if (!n && !o) { + var i = pe.lookupPath(r, { follow_mount: !1 }); + if (((r = i.path), (A = i.node), pe.isMountpoint(A))) + throw new pe.ErrnoError(10); + if (!pe.isDir(A.mode)) throw new pe.ErrnoError(54); + } + var s = { type: e, opts: t, mountpoint: r, mounts: [] }, + a = e.mount(s); + return ( + (a.mount = s), + (s.root = a), + n + ? (pe.root = a) + : A && ((A.mounted = s), A.mount && A.mount.mounts.push(s)), + a + ); + }, + unmount: function (e) { + var t = pe.lookupPath(e, { follow_mount: !1 }); + if (!pe.isMountpoint(t.node)) throw new pe.ErrnoError(28); + var r = t.node, + A = r.mounted, + n = pe.getMounts(A); + Object.keys(pe.nameTable).forEach(function (e) { + for (var t = pe.nameTable[e]; t; ) { + var r = t.name_next; + -1 !== n.indexOf(t.mount) && pe.destroyNode(t), (t = r); + } + }), + (r.mounted = null); + var o = r.mount.mounts.indexOf(A); + r.mount.mounts.splice(o, 1); + }, + lookup: function (e, t) { + return e.node_ops.lookup(e, t); + }, + mknod: function (e, t, r) { + var A = pe.lookupPath(e, { parent: !0 }).node, + n = ie.basename(e); + if (!n || '.' === n || '..' === n) throw new pe.ErrnoError(28); + var o = pe.mayCreate(A, n); + if (o) throw new pe.ErrnoError(o); + if (!A.node_ops.mknod) throw new pe.ErrnoError(63); + return A.node_ops.mknod(A, n, t, r); + }, + create: function (e, t) { + return ( + (t = void 0 !== t ? t : 438), + (t &= 4095), + (t |= 32768), + pe.mknod(e, t, 0) + ); + }, + mkdir: function (e, t) { + return ( + (t = void 0 !== t ? t : 511), + (t &= 1023), + (t |= 16384), + pe.mknod(e, t, 0) + ); + }, + mkdirTree: function (e, t) { + for (var r = e.split('/'), A = '', n = 0; n < r.length; ++n) + if (r[n]) { + A += '/' + r[n]; + try { + pe.mkdir(A, t); + } catch (e) { + if (20 != e.errno) throw e; + } + } + }, + mkdev: function (e, t, r) { + return ( + void 0 === r && ((r = t), (t = 438)), + (t |= 8192), + pe.mknod(e, t, r) + ); + }, + symlink: function (e, t) { + if (!ae.resolve(e)) throw new pe.ErrnoError(44); + var r = pe.lookupPath(t, { parent: !0 }).node; + if (!r) throw new pe.ErrnoError(44); + var A = ie.basename(t), + n = pe.mayCreate(r, A); + if (n) throw new pe.ErrnoError(n); + if (!r.node_ops.symlink) throw new pe.ErrnoError(63); + return r.node_ops.symlink(r, A, e); + }, + rename: function (e, t) { + var r, + A, + n = ie.dirname(e), + o = ie.dirname(t), + i = ie.basename(e), + s = ie.basename(t); + if ( + ((r = pe.lookupPath(e, { parent: !0 }).node), + (A = pe.lookupPath(t, { parent: !0 }).node), + !r || !A) + ) + throw new pe.ErrnoError(44); + if (r.mount !== A.mount) throw new pe.ErrnoError(75); + var a, + c = pe.lookupNode(r, i), + g = ae.relative(e, o); + if ('.' !== g.charAt(0)) throw new pe.ErrnoError(28); + if ('.' !== (g = ae.relative(t, n)).charAt(0)) + throw new pe.ErrnoError(55); + try { + a = pe.lookupNode(A, s); + } catch (e) {} + if (c !== a) { + var l = pe.isDir(c.mode), + u = pe.mayDelete(r, i, l); + if (u) throw new pe.ErrnoError(u); + if ((u = a ? pe.mayDelete(A, s, l) : pe.mayCreate(A, s))) + throw new pe.ErrnoError(u); + if (!r.node_ops.rename) throw new pe.ErrnoError(63); + if (pe.isMountpoint(c) || (a && pe.isMountpoint(a))) + throw new pe.ErrnoError(10); + if (A !== r && (u = pe.nodePermissions(r, 'w'))) + throw new pe.ErrnoError(u); + try { + pe.trackingDelegate.willMovePath && + pe.trackingDelegate.willMovePath(e, t); + } catch (r) { + p( + "FS.trackingDelegate['willMovePath']('" + + e + + "', '" + + t + + "') threw an exception: " + + r.message + ); + } + pe.hashRemoveNode(c); + try { + r.node_ops.rename(c, A, s); + } catch (e) { + throw e; + } finally { + pe.hashAddNode(c); + } + try { + pe.trackingDelegate.onMovePath && + pe.trackingDelegate.onMovePath(e, t); + } catch (r) { + p( + "FS.trackingDelegate['onMovePath']('" + + e + + "', '" + + t + + "') threw an exception: " + + r.message + ); + } + } + }, + rmdir: function (e) { + var t = pe.lookupPath(e, { parent: !0 }).node, + r = ie.basename(e), + A = pe.lookupNode(t, r), + n = pe.mayDelete(t, r, !0); + if (n) throw new pe.ErrnoError(n); + if (!t.node_ops.rmdir) throw new pe.ErrnoError(63); + if (pe.isMountpoint(A)) throw new pe.ErrnoError(10); + try { + pe.trackingDelegate.willDeletePath && + pe.trackingDelegate.willDeletePath(e); + } catch (t) { + p( + "FS.trackingDelegate['willDeletePath']('" + + e + + "') threw an exception: " + + t.message + ); + } + t.node_ops.rmdir(t, r), pe.destroyNode(A); + try { + pe.trackingDelegate.onDeletePath && + pe.trackingDelegate.onDeletePath(e); + } catch (t) { + p( + "FS.trackingDelegate['onDeletePath']('" + + e + + "') threw an exception: " + + t.message + ); + } + }, + readdir: function (e) { + var t = pe.lookupPath(e, { follow: !0 }).node; + if (!t.node_ops.readdir) throw new pe.ErrnoError(54); + return t.node_ops.readdir(t); + }, + unlink: function (e) { + var t = pe.lookupPath(e, { parent: !0 }).node, + r = ie.basename(e), + A = pe.lookupNode(t, r), + n = pe.mayDelete(t, r, !1); + if (n) throw new pe.ErrnoError(n); + if (!t.node_ops.unlink) throw new pe.ErrnoError(63); + if (pe.isMountpoint(A)) throw new pe.ErrnoError(10); + try { + pe.trackingDelegate.willDeletePath && + pe.trackingDelegate.willDeletePath(e); + } catch (t) { + p( + "FS.trackingDelegate['willDeletePath']('" + + e + + "') threw an exception: " + + t.message + ); + } + t.node_ops.unlink(t, r), pe.destroyNode(A); + try { + pe.trackingDelegate.onDeletePath && + pe.trackingDelegate.onDeletePath(e); + } catch (t) { + p( + "FS.trackingDelegate['onDeletePath']('" + + e + + "') threw an exception: " + + t.message + ); + } + }, + readlink: function (e) { + var t = pe.lookupPath(e).node; + if (!t) throw new pe.ErrnoError(44); + if (!t.node_ops.readlink) throw new pe.ErrnoError(28); + return ae.resolve(pe.getPath(t.parent), t.node_ops.readlink(t)); + }, + stat: function (e, t) { + var r = pe.lookupPath(e, { follow: !t }).node; + if (!r) throw new pe.ErrnoError(44); + if (!r.node_ops.getattr) throw new pe.ErrnoError(63); + return r.node_ops.getattr(r); + }, + lstat: function (e) { + return pe.stat(e, !0); + }, + chmod: function (e, t, r) { + var A; + 'string' == typeof e + ? (A = pe.lookupPath(e, { follow: !r }).node) + : (A = e); + if (!A.node_ops.setattr) throw new pe.ErrnoError(63); + A.node_ops.setattr(A, { + mode: (4095 & t) | (-4096 & A.mode), + timestamp: Date.now(), + }); + }, + lchmod: function (e, t) { + pe.chmod(e, t, !0); + }, + fchmod: function (e, t) { + var r = pe.getStream(e); + if (!r) throw new pe.ErrnoError(8); + pe.chmod(r.node, t); + }, + chown: function (e, t, r, A) { + var n; + 'string' == typeof e + ? (n = pe.lookupPath(e, { follow: !A }).node) + : (n = e); + if (!n.node_ops.setattr) throw new pe.ErrnoError(63); + n.node_ops.setattr(n, { timestamp: Date.now() }); + }, + lchown: function (e, t, r) { + pe.chown(e, t, r, !0); + }, + fchown: function (e, t, r) { + var A = pe.getStream(e); + if (!A) throw new pe.ErrnoError(8); + pe.chown(A.node, t, r); + }, + truncate: function (e, t) { + if (t < 0) throw new pe.ErrnoError(28); + var r; + 'string' == typeof e + ? (r = pe.lookupPath(e, { follow: !0 }).node) + : (r = e); + if (!r.node_ops.setattr) throw new pe.ErrnoError(63); + if (pe.isDir(r.mode)) throw new pe.ErrnoError(31); + if (!pe.isFile(r.mode)) throw new pe.ErrnoError(28); + var A = pe.nodePermissions(r, 'w'); + if (A) throw new pe.ErrnoError(A); + r.node_ops.setattr(r, { size: t, timestamp: Date.now() }); + }, + ftruncate: function (e, t) { + var r = pe.getStream(e); + if (!r) throw new pe.ErrnoError(8); + if (0 == (2097155 & r.flags)) throw new pe.ErrnoError(28); + pe.truncate(r.node, t); + }, + utime: function (e, t, r) { + var A = pe.lookupPath(e, { follow: !0 }).node; + A.node_ops.setattr(A, { timestamp: Math.max(t, r) }); + }, + open: function (e, t, r, A, n) { + if ('' === e) throw new pe.ErrnoError(44); + var i; + if ( + ((r = void 0 === r ? 438 : r), + (r = + 64 & (t = 'string' == typeof t ? pe.modeStringToFlags(t) : t) + ? (4095 & r) | 32768 + : 0), + 'object' == typeof e) + ) + i = e; + else { + e = ie.normalize(e); + try { + i = pe.lookupPath(e, { follow: !(131072 & t) }).node; + } catch (e) {} + } + var s = !1; + if (64 & t) + if (i) { + if (128 & t) throw new pe.ErrnoError(20); + } else (i = pe.mknod(e, r, 0)), (s = !0); + if (!i) throw new pe.ErrnoError(44); + if ( + (pe.isChrdev(i.mode) && (t &= -513), + 65536 & t && !pe.isDir(i.mode)) + ) + throw new pe.ErrnoError(54); + if (!s) { + var a = pe.mayOpen(i, t); + if (a) throw new pe.ErrnoError(a); + } + 512 & t && pe.truncate(i, 0), (t &= -131713); + var c = pe.createStream( + { + node: i, + path: pe.getPath(i), + flags: t, + seekable: !0, + position: 0, + stream_ops: i.stream_ops, + ungotten: [], + error: !1, + }, + A, + n + ); + c.stream_ops.open && c.stream_ops.open(c), + !o.logReadFiles || + 1 & t || + (pe.readFiles || (pe.readFiles = {}), + e in pe.readFiles || + ((pe.readFiles[e] = 1), + p('FS.trackingDelegate error on read file: ' + e))); + try { + if (pe.trackingDelegate.onOpenFile) { + var g = 0; + 1 != (2097155 & t) && (g |= pe.tracking.openFlags.READ), + 0 != (2097155 & t) && (g |= pe.tracking.openFlags.WRITE), + pe.trackingDelegate.onOpenFile(e, g); + } + } catch (t) { + p( + "FS.trackingDelegate['onOpenFile']('" + + e + + "', flags) threw an exception: " + + t.message + ); + } + return c; + }, + close: function (e) { + if (pe.isClosed(e)) throw new pe.ErrnoError(8); + e.getdents && (e.getdents = null); + try { + e.stream_ops.close && e.stream_ops.close(e); + } catch (e) { + throw e; + } finally { + pe.closeStream(e.fd); + } + e.fd = null; + }, + isClosed: function (e) { + return null === e.fd; + }, + llseek: function (e, t, r) { + if (pe.isClosed(e)) throw new pe.ErrnoError(8); + if (!e.seekable || !e.stream_ops.llseek) + throw new pe.ErrnoError(70); + if (0 != r && 1 != r && 2 != r) throw new pe.ErrnoError(28); + return ( + (e.position = e.stream_ops.llseek(e, t, r)), + (e.ungotten = []), + e.position + ); + }, + read: function (e, t, r, A, n) { + if (A < 0 || n < 0) throw new pe.ErrnoError(28); + if (pe.isClosed(e)) throw new pe.ErrnoError(8); + if (1 == (2097155 & e.flags)) throw new pe.ErrnoError(8); + if (pe.isDir(e.node.mode)) throw new pe.ErrnoError(31); + if (!e.stream_ops.read) throw new pe.ErrnoError(28); + var o = void 0 !== n; + if (o) { + if (!e.seekable) throw new pe.ErrnoError(70); + } else n = e.position; + var i = e.stream_ops.read(e, t, r, A, n); + return o || (e.position += i), i; + }, + write: function (e, t, r, A, n, o) { + if (A < 0 || n < 0) throw new pe.ErrnoError(28); + if (pe.isClosed(e)) throw new pe.ErrnoError(8); + if (0 == (2097155 & e.flags)) throw new pe.ErrnoError(8); + if (pe.isDir(e.node.mode)) throw new pe.ErrnoError(31); + if (!e.stream_ops.write) throw new pe.ErrnoError(28); + e.seekable && 1024 & e.flags && pe.llseek(e, 0, 2); + var i = void 0 !== n; + if (i) { + if (!e.seekable) throw new pe.ErrnoError(70); + } else n = e.position; + var s = e.stream_ops.write(e, t, r, A, n, o); + i || (e.position += s); + try { + e.path && + pe.trackingDelegate.onWriteToFile && + pe.trackingDelegate.onWriteToFile(e.path); + } catch (t) { + p( + "FS.trackingDelegate['onWriteToFile']('" + + e.path + + "') threw an exception: " + + t.message + ); + } + return s; + }, + allocate: function (e, t, r) { + if (pe.isClosed(e)) throw new pe.ErrnoError(8); + if (t < 0 || r <= 0) throw new pe.ErrnoError(28); + if (0 == (2097155 & e.flags)) throw new pe.ErrnoError(8); + if (!pe.isFile(e.node.mode) && !pe.isDir(e.node.mode)) + throw new pe.ErrnoError(43); + if (!e.stream_ops.allocate) throw new pe.ErrnoError(138); + e.stream_ops.allocate(e, t, r); + }, + mmap: function (e, t, r, A, n, o) { + if (0 != (2 & n) && 0 == (2 & o) && 2 != (2097155 & e.flags)) + throw new pe.ErrnoError(2); + if (1 == (2097155 & e.flags)) throw new pe.ErrnoError(2); + if (!e.stream_ops.mmap) throw new pe.ErrnoError(43); + return e.stream_ops.mmap(e, t, r, A, n, o); + }, + msync: function (e, t, r, A, n) { + return e && e.stream_ops.msync + ? e.stream_ops.msync(e, t, r, A, n) + : 0; + }, + munmap: function (e) { + return 0; + }, + ioctl: function (e, t, r) { + if (!e.stream_ops.ioctl) throw new pe.ErrnoError(59); + return e.stream_ops.ioctl(e, t, r); + }, + readFile: function (e, t) { + if ( + (((t = t || {}).flags = t.flags || 'r'), + (t.encoding = t.encoding || 'binary'), + 'utf8' !== t.encoding && 'binary' !== t.encoding) + ) + throw new Error('Invalid encoding type "' + t.encoding + '"'); + var r, + A = pe.open(e, t.flags), + n = pe.stat(e).size, + o = new Uint8Array(n); + return ( + pe.read(A, o, 0, n, 0), + 'utf8' === t.encoding + ? (r = w(o, 0)) + : 'binary' === t.encoding && (r = o), + pe.close(A), + r + ); + }, + writeFile: function (e, t, r) { + (r = r || {}).flags = r.flags || 'w'; + var A = pe.open(e, r.flags, r.mode); + if ('string' == typeof t) { + var n = new Uint8Array(v(t) + 1), + o = D(t, n, 0, n.length); + pe.write(A, n, 0, o, void 0, r.canOwn); + } else { + if (!ArrayBuffer.isView(t)) + throw new Error('Unsupported data type'); + pe.write(A, t, 0, t.byteLength, void 0, r.canOwn); + } + pe.close(A); + }, + cwd: function () { + return pe.currentPath; + }, + chdir: function (e) { + var t = pe.lookupPath(e, { follow: !0 }); + if (null === t.node) throw new pe.ErrnoError(44); + if (!pe.isDir(t.node.mode)) throw new pe.ErrnoError(54); + var r = pe.nodePermissions(t.node, 'x'); + if (r) throw new pe.ErrnoError(r); + pe.currentPath = t.path; + }, + createDefaultDirectories: function () { + pe.mkdir('/tmp'), pe.mkdir('/home'), pe.mkdir('/home/web_user'); + }, + createDefaultDevices: function () { + var e; + if ( + (pe.mkdir('/dev'), + pe.registerDevice(pe.makedev(1, 3), { + read: function () { + return 0; + }, + write: function (e, t, r, A, n) { + return A; + }, + }), + pe.mkdev('/dev/null', pe.makedev(1, 3)), + ce.register(pe.makedev(5, 0), ce.default_tty_ops), + ce.register(pe.makedev(6, 0), ce.default_tty1_ops), + pe.mkdev('/dev/tty', pe.makedev(5, 0)), + pe.mkdev('/dev/tty1', pe.makedev(6, 0)), + 'object' == typeof crypto && + 'function' == typeof crypto.getRandomValues) + ) { + var t = new Uint8Array(1); + e = function () { + return crypto.getRandomValues(t), t[0]; + }; + } else { + try { + var A = r(76417); + e = function () { + return A.randomBytes(1)[0]; + }; + } catch (e) {} + } + e || + (e = function () { + _('random_device'); + }), + pe.createDevice('/dev', 'random', e), + pe.createDevice('/dev', 'urandom', e), + pe.mkdir('/dev/shm'), + pe.mkdir('/dev/shm/tmp'); + }, + createSpecialDirectories: function () { + pe.mkdir('/proc'), + pe.mkdir('/proc/self'), + pe.mkdir('/proc/self/fd'), + pe.mount( + { + mount: function () { + var e = pe.createNode('/proc/self', 'fd', 16895, 73); + return ( + (e.node_ops = { + lookup: function (e, t) { + var r = +t, + A = pe.getStream(r); + if (!A) throw new pe.ErrnoError(8); + var n = { + parent: null, + mount: { mountpoint: 'fake' }, + node_ops: { + readlink: function () { + return A.path; + }, + }, + }; + return (n.parent = n), n; + }, + }), + e + ); + }, + }, + {}, + '/proc/self/fd' + ); + }, + createStandardStreams: function () { + o.stdin + ? pe.createDevice('/dev', 'stdin', o.stdin) + : pe.symlink('/dev/tty', '/dev/stdin'), + o.stdout + ? pe.createDevice('/dev', 'stdout', null, o.stdout) + : pe.symlink('/dev/tty', '/dev/stdout'), + o.stderr + ? pe.createDevice('/dev', 'stderr', null, o.stderr) + : pe.symlink('/dev/tty1', '/dev/stderr'); + pe.open('/dev/stdin', 'r'), + pe.open('/dev/stdout', 'w'), + pe.open('/dev/stderr', 'w'); + }, + ensureErrnoError: function () { + pe.ErrnoError || + ((pe.ErrnoError = function (e, t) { + (this.node = t), + (this.setErrno = function (e) { + this.errno = e; + }), + this.setErrno(e), + (this.message = 'FS error'); + }), + (pe.ErrnoError.prototype = new Error()), + (pe.ErrnoError.prototype.constructor = pe.ErrnoError), + [44].forEach(function (e) { + (pe.genericErrors[e] = new pe.ErrnoError(e)), + (pe.genericErrors[e].stack = ''); + })); + }, + staticInit: function () { + pe.ensureErrnoError(), + (pe.nameTable = new Array(4096)), + pe.mount(ge, {}, '/'), + pe.createDefaultDirectories(), + pe.createDefaultDevices(), + pe.createSpecialDirectories(), + (pe.filesystems = { MEMFS: ge, NODEFS: ue }); + }, + init: function (e, t, r) { + (pe.init.initialized = !0), + pe.ensureErrnoError(), + (o.stdin = e || o.stdin), + (o.stdout = t || o.stdout), + (o.stderr = r || o.stderr), + pe.createStandardStreams(); + }, + quit: function () { + pe.init.initialized = !1; + var e = o._fflush; + e && e(0); + for (var t = 0; t < pe.streams.length; t++) { + var r = pe.streams[t]; + r && pe.close(r); + } + }, + getMode: function (e, t) { + var r = 0; + return e && (r |= 365), t && (r |= 146), r; + }, + joinPath: function (e, t) { + var r = ie.join.apply(null, e); + return t && '/' == r[0] && (r = r.substr(1)), r; + }, + absolutePath: function (e, t) { + return ae.resolve(t, e); + }, + standardizePath: function (e) { + return ie.normalize(e); + }, + findObject: function (e, t) { + var r = pe.analyzePath(e, t); + return r.exists ? r.object : (se(r.error), null); + }, + analyzePath: function (e, t) { + try { + e = (A = pe.lookupPath(e, { follow: !t })).path; + } catch (e) {} + var r = { + isRoot: !1, + exists: !1, + error: 0, + name: null, + path: null, + object: null, + parentExists: !1, + parentPath: null, + parentObject: null, + }; + try { + var A = pe.lookupPath(e, { parent: !0 }); + (r.parentExists = !0), + (r.parentPath = A.path), + (r.parentObject = A.node), + (r.name = ie.basename(e)), + (A = pe.lookupPath(e, { follow: !t })), + (r.exists = !0), + (r.path = A.path), + (r.object = A.node), + (r.name = A.node.name), + (r.isRoot = '/' === A.path); + } catch (e) { + r.error = e.errno; + } + return r; + }, + createFolder: function (e, t, r, A) { + var n = ie.join2('string' == typeof e ? e : pe.getPath(e), t), + o = pe.getMode(r, A); + return pe.mkdir(n, o); + }, + createPath: function (e, t, r, A) { + e = 'string' == typeof e ? e : pe.getPath(e); + for (var n = t.split('/').reverse(); n.length; ) { + var o = n.pop(); + if (o) { + var i = ie.join2(e, o); + try { + pe.mkdir(i); + } catch (e) {} + e = i; + } + } + return i; + }, + createFile: function (e, t, r, A, n) { + var o = ie.join2('string' == typeof e ? e : pe.getPath(e), t), + i = pe.getMode(A, n); + return pe.create(o, i); + }, + createDataFile: function (e, t, r, A, n, o) { + var i = t + ? ie.join2('string' == typeof e ? e : pe.getPath(e), t) + : e, + s = pe.getMode(A, n), + a = pe.create(i, s); + if (r) { + if ('string' == typeof r) { + for ( + var c = new Array(r.length), g = 0, l = r.length; + g < l; + ++g + ) + c[g] = r.charCodeAt(g); + r = c; + } + pe.chmod(a, 146 | s); + var u = pe.open(a, 'w'); + pe.write(u, r, 0, r.length, 0, o), pe.close(u), pe.chmod(a, s); + } + return a; + }, + createDevice: function (e, t, r, A) { + var n = ie.join2('string' == typeof e ? e : pe.getPath(e), t), + o = pe.getMode(!!r, !!A); + pe.createDevice.major || (pe.createDevice.major = 64); + var i = pe.makedev(pe.createDevice.major++, 0); + return ( + pe.registerDevice(i, { + open: function (e) { + e.seekable = !1; + }, + close: function (e) { + A && A.buffer && A.buffer.length && A(10); + }, + read: function (e, t, A, n, o) { + for (var i = 0, s = 0; s < n; s++) { + var a; + try { + a = r(); + } catch (e) { + throw new pe.ErrnoError(29); + } + if (void 0 === a && 0 === i) throw new pe.ErrnoError(6); + if (null == a) break; + i++, (t[A + s] = a); + } + return i && (e.node.timestamp = Date.now()), i; + }, + write: function (e, t, r, n, o) { + for (var i = 0; i < n; i++) + try { + A(t[r + i]); + } catch (e) { + throw new pe.ErrnoError(29); + } + return n && (e.node.timestamp = Date.now()), i; + }, + }), + pe.mkdev(n, o, i) + ); + }, + createLink: function (e, t, r, A, n) { + var o = ie.join2('string' == typeof e ? e : pe.getPath(e), t); + return pe.symlink(r, o); + }, + forceLoadFile: function (e) { + if (e.isDevice || e.isFolder || e.link || e.contents) return !0; + var t = !0; + if ('undefined' != typeof XMLHttpRequest) + throw new Error( + 'Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.' + ); + if (!s) + throw new Error( + 'Cannot load without read() or XMLHttpRequest.' + ); + try { + (e.contents = we(s(e.url), !0)), + (e.usedBytes = e.contents.length); + } catch (e) { + t = !1; + } + return t || se(29), t; + }, + createLazyFile: function (e, t, r, A, n) { + function o() { + (this.lengthKnown = !1), (this.chunks = []); + } + if ( + ((o.prototype.get = function (e) { + if (!(e > this.length - 1 || e < 0)) { + var t = e % this.chunkSize, + r = (e / this.chunkSize) | 0; + return this.getter(r)[t]; + } + }), + (o.prototype.setDataGetter = function (e) { + this.getter = e; + }), + (o.prototype.cacheLength = function () { + var e = new XMLHttpRequest(); + if ( + (e.open('HEAD', r, !1), + e.send(null), + !((e.status >= 200 && e.status < 300) || 304 === e.status)) + ) + throw new Error( + "Couldn't load " + r + '. Status: ' + e.status + ); + var t, + A = Number(e.getResponseHeader('Content-length')), + n = + (t = e.getResponseHeader('Accept-Ranges')) && + 'bytes' === t, + o = + (t = e.getResponseHeader('Content-Encoding')) && + 'gzip' === t, + i = 1048576; + n || (i = A); + var s = this; + s.setDataGetter(function (e) { + var t = e * i, + n = (e + 1) * i - 1; + if ( + ((n = Math.min(n, A - 1)), + void 0 === s.chunks[e] && + (s.chunks[e] = (function (e, t) { + if (e > t) + throw new Error( + 'invalid range (' + + e + + ', ' + + t + + ') or no bytes requested!' + ); + if (t > A - 1) + throw new Error( + 'only ' + + A + + ' bytes available! programmer error!' + ); + var n = new XMLHttpRequest(); + if ( + (n.open('GET', r, !1), + A !== i && + n.setRequestHeader( + 'Range', + 'bytes=' + e + '-' + t + ), + 'undefined' != typeof Uint8Array && + (n.responseType = 'arraybuffer'), + n.overrideMimeType && + n.overrideMimeType( + 'text/plain; charset=x-user-defined' + ), + n.send(null), + !( + (n.status >= 200 && n.status < 300) || + 304 === n.status + )) + ) + throw new Error( + "Couldn't load " + r + '. Status: ' + n.status + ); + return void 0 !== n.response + ? new Uint8Array(n.response || []) + : we(n.responseText || '', !0); + })(t, n)), + void 0 === s.chunks[e]) + ) + throw new Error('doXHR failed!'); + return s.chunks[e]; + }), + (!o && A) || + ((i = A = 1), + (A = this.getter(0).length), + (i = A), + h( + 'LazyFiles on gzip forces download of the whole file when length is accessed' + )), + (this._length = A), + (this._chunkSize = i), + (this.lengthKnown = !0); + }), + 'undefined' != typeof XMLHttpRequest) + ) + throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc'; + var i = { isDevice: !1, url: r }, + s = pe.createFile(e, t, i, A, n); + i.contents + ? (s.contents = i.contents) + : i.url && ((s.contents = null), (s.url = i.url)), + Object.defineProperties(s, { + usedBytes: { + get: function () { + return this.contents.length; + }, + }, + }); + var a = {}; + return ( + Object.keys(s.stream_ops).forEach(function (e) { + var t = s.stream_ops[e]; + a[e] = function () { + if (!pe.forceLoadFile(s)) throw new pe.ErrnoError(29); + return t.apply(null, arguments); + }; + }), + (a.read = function (e, t, r, A, n) { + if (!pe.forceLoadFile(s)) throw new pe.ErrnoError(29); + var o = e.node.contents; + if (n >= o.length) return 0; + var i = Math.min(o.length - n, A); + if (o.slice) for (var a = 0; a < i; a++) t[r + a] = o[n + a]; + else for (a = 0; a < i; a++) t[r + a] = o.get(n + a); + return i; + }), + (s.stream_ops = a), + s + ); + }, + createPreloadedFile: function (e, t, r, A, n, i, s, a, c, g) { + Browser.init(); + var l = t ? ae.resolve(ie.join2(e, t)) : e; + function u(r) { + function u(r) { + g && g(), + a || pe.createDataFile(e, t, r, A, n, c), + i && i(), + X(); + } + var h = !1; + o.preloadPlugins.forEach(function (e) { + h || + (e.canHandle(l) && + (e.handle(r, l, u, function () { + s && s(), X(); + }), + (h = !0))); + }), + h || u(r); + } + V(), + 'string' == typeof r + ? Browser.asyncLoad( + r, + function (e) { + u(e); + }, + s + ) + : u(r); + }, + indexedDB: function () { + return ( + window.indexedDB || + window.mozIndexedDB || + window.webkitIndexedDB || + window.msIndexedDB + ); + }, + DB_NAME: function () { + return 'EM_FS_' + window.location.pathname; + }, + DB_VERSION: 20, + DB_STORE_NAME: 'FILE_DATA', + saveFilesToDB: function (e, t, r) { + (t = t || function () {}), (r = r || function () {}); + var A = pe.indexedDB(); + try { + var n = A.open(pe.DB_NAME(), pe.DB_VERSION); + } catch (e) { + return r(e); + } + (n.onupgradeneeded = function () { + h('creating db'), n.result.createObjectStore(pe.DB_STORE_NAME); + }), + (n.onsuccess = function () { + var A = n.result.transaction([pe.DB_STORE_NAME], 'readwrite'), + o = A.objectStore(pe.DB_STORE_NAME), + i = 0, + s = 0, + a = e.length; + function c() { + 0 == s ? t() : r(); + } + e.forEach(function (e) { + var t = o.put(pe.analyzePath(e).object.contents, e); + (t.onsuccess = function () { + ++i + s == a && c(); + }), + (t.onerror = function () { + s++, i + s == a && c(); + }); + }), + (A.onerror = r); + }), + (n.onerror = r); + }, + loadFilesFromDB: function (e, t, r) { + (t = t || function () {}), (r = r || function () {}); + var A = pe.indexedDB(); + try { + var n = A.open(pe.DB_NAME(), pe.DB_VERSION); + } catch (e) { + return r(e); + } + (n.onupgradeneeded = r), + (n.onsuccess = function () { + var A = n.result; + try { + var o = A.transaction([pe.DB_STORE_NAME], 'readonly'); + } catch (e) { + return void r(e); + } + var i = o.objectStore(pe.DB_STORE_NAME), + s = 0, + a = 0, + c = e.length; + function g() { + 0 == a ? t() : r(); + } + e.forEach(function (e) { + var t = i.get(e); + (t.onsuccess = function () { + pe.analyzePath(e).exists && pe.unlink(e), + pe.createDataFile( + ie.dirname(e), + ie.basename(e), + t.result, + !0, + !0, + !0 + ), + ++s + a == c && g(); + }), + (t.onerror = function () { + a++, s + a == c && g(); + }); + }), + (o.onerror = r); + }), + (n.onerror = r); + }, + mmapAlloc: function (e) { + for ( + var t = (function (e, t) { + return t || (t = 16), Math.ceil(e / t) * t; + })(e, 16384), + r = Le(t); + e < t; + + ) + N[r + e++] = 0; + return r; + }, + }, + de = { + mappings: {}, + DEFAULT_POLLMASK: 5, + umask: 511, + calculateAt: function (e, t) { + if ('/' !== t[0]) { + var r; + if (-100 === e) r = pe.cwd(); + else { + var A = pe.getStream(e); + if (!A) throw new pe.ErrnoError(8); + r = A.path; + } + t = ie.join2(r, t); + } + return t; + }, + doStat: function (e, t, r) { + try { + var A = e(t); + } catch (e) { + if ( + e && + e.node && + ie.normalize(t) !== ie.normalize(pe.getPath(e.node)) + ) + return -54; + throw e; + } + return ( + (M[r >> 2] = A.dev), + (M[(r + 4) >> 2] = 0), + (M[(r + 8) >> 2] = A.ino), + (M[(r + 12) >> 2] = A.mode), + (M[(r + 16) >> 2] = A.nlink), + (M[(r + 20) >> 2] = A.uid), + (M[(r + 24) >> 2] = A.gid), + (M[(r + 28) >> 2] = A.rdev), + (M[(r + 32) >> 2] = 0), + (te = [ + A.size >>> 0, + ((ee = A.size), + +Y(ee) >= 1 + ? ee > 0 + ? (0 | J(+H(ee / 4294967296), 4294967295)) >>> 0 + : ~~+G((ee - +(~~ee >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (M[(r + 40) >> 2] = te[0]), + (M[(r + 44) >> 2] = te[1]), + (M[(r + 48) >> 2] = 4096), + (M[(r + 52) >> 2] = A.blocks), + (M[(r + 56) >> 2] = (A.atime.getTime() / 1e3) | 0), + (M[(r + 60) >> 2] = 0), + (M[(r + 64) >> 2] = (A.mtime.getTime() / 1e3) | 0), + (M[(r + 68) >> 2] = 0), + (M[(r + 72) >> 2] = (A.ctime.getTime() / 1e3) | 0), + (M[(r + 76) >> 2] = 0), + (te = [ + A.ino >>> 0, + ((ee = A.ino), + +Y(ee) >= 1 + ? ee > 0 + ? (0 | J(+H(ee / 4294967296), 4294967295)) >>> 0 + : ~~+G((ee - +(~~ee >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (M[(r + 80) >> 2] = te[0]), + (M[(r + 84) >> 2] = te[1]), + 0 + ); + }, + doMsync: function (e, t, r, A, n) { + var o = F.slice(e, e + r); + pe.msync(t, o, n, r, A); + }, + doMkdir: function (e, t) { + return ( + '/' === (e = ie.normalize(e))[e.length - 1] && + (e = e.substr(0, e.length - 1)), + pe.mkdir(e, t, 0), + 0 + ); + }, + doMknod: function (e, t, r) { + switch (61440 & t) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: + return -28; + } + return pe.mknod(e, t, r), 0; + }, + doReadlink: function (e, t, r) { + if (r <= 0) return -28; + var A = pe.readlink(e), + n = Math.min(r, v(A)), + o = N[t + n]; + return b(A, t, r + 1), (N[t + n] = o), n; + }, + doAccess: function (e, t) { + if (-8 & t) return -28; + var r; + if (!(r = pe.lookupPath(e, { follow: !0 }).node)) return -44; + var A = ''; + return ( + 4 & t && (A += 'r'), + 2 & t && (A += 'w'), + 1 & t && (A += 'x'), + A && pe.nodePermissions(r, A) ? -2 : 0 + ); + }, + doDup: function (e, t, r) { + var A = pe.getStream(r); + return A && pe.close(A), pe.open(e, t, 0, r, r).fd; + }, + doReadv: function (e, t, r, A) { + for (var n = 0, o = 0; o < r; o++) { + var i = M[(t + 8 * o) >> 2], + s = M[(t + (8 * o + 4)) >> 2], + a = pe.read(e, N, i, s, A); + if (a < 0) return -1; + if (((n += a), a < s)) break; + } + return n; + }, + doWritev: function (e, t, r, A) { + for (var n = 0, o = 0; o < r; o++) { + var i = M[(t + 8 * o) >> 2], + s = M[(t + (8 * o + 4)) >> 2], + a = pe.write(e, N, i, s, A); + if (a < 0) return -1; + n += a; + } + return n; + }, + varargs: void 0, + get: function () { + return (de.varargs += 4), M[(de.varargs - 4) >> 2]; + }, + getStr: function (e) { + return Q(e); + }, + getStreamFromFD: function (e) { + var t = pe.getStream(e); + if (!t) throw new pe.ErrnoError(8); + return t; + }, + get64: function (e, t) { + return e; + }, + }; + function Ce(e) { + try { + return C.grow((e - k.byteLength + 65535) >>> 16), L(C.buffer), 1; + } catch (e) {} + } + var fe = function (e, t, r, A) { + e || (e = this), + (this.parent = e), + (this.mount = e.mount), + (this.mounted = null), + (this.id = pe.nextInode++), + (this.name = t), + (this.mode = r), + (this.node_ops = {}), + (this.stream_ops = {}), + (this.rdev = A); + }; + Object.defineProperties(fe.prototype, { + read: { + get: function () { + return 365 == (365 & this.mode); + }, + set: function (e) { + e ? (this.mode |= 365) : (this.mode &= -366); + }, + }, + write: { + get: function () { + return 146 == (146 & this.mode); + }, + set: function (e) { + e ? (this.mode |= 146) : (this.mode &= -147); + }, + }, + isFolder: { + get: function () { + return pe.isDir(this.mode); + }, + }, + isDevice: { + get: function () { + return pe.isChrdev(this.mode); + }, + }, + }), + (pe.FSNode = fe), + pe.staticInit(); + var Ie = n, + Ee = r(85622); + ue.staticInit(); + var Be = function (e) { + return function () { + try { + return e.apply(this, arguments); + } catch (e) { + if (!e.code) throw e; + throw new pe.ErrnoError(le[e.code]); + } + }; + }, + ye = Object.assign({}, pe); + for (var me in he) pe[me] = Be(he[me]); + function we(e, t, r) { + var A = r > 0 ? r : v(e) + 1, + n = new Array(A), + o = D(e, n, 0, n.length); + return t && (n.length = o), n; + } + 'function' == typeof atob && atob; + function Qe(e) { + if (Z(e)) + return (function (e) { + var t; + try { + t = Buffer.from(e, 'base64'); + } catch (r) { + t = new Buffer(e, 'base64'); + } + return new Uint8Array(t.buffer, t.byteOffset, t.byteLength); + })(e.slice('data:application/octet-stream;base64,'.length)); + } + var De, + be = { + m: function (e, t) { + return oe(e, t); + }, + b: f, + r: function (e, t) { + try { + return (e = de.getStr(e)), pe.chmod(e, t), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + g: function (e, t, r) { + de.varargs = r; + try { + var A = de.getStreamFromFD(e); + switch (t) { + case 0: + return (n = de.get()) < 0 + ? -28 + : pe.open(A.path, A.flags, 0, n).fd; + case 1: + case 2: + return 0; + case 3: + return A.flags; + case 4: + var n = de.get(); + return (A.flags |= n), 0; + case 12: + n = de.get(); + return (K[(n + 0) >> 1] = 2), 0; + case 13: + case 14: + return 0; + case 16: + case 8: + return -28; + case 9: + return se(28), -1; + default: + return -28; + } + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + l: function (e, t) { + try { + var r = de.getStreamFromFD(e); + return de.doStat(pe.stat, r.path, t); + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + q: function (e, t, r) { + de.varargs = r; + try { + var A = de.getStreamFromFD(e); + switch (t) { + case 21509: + case 21505: + return A.tty ? 0 : -59; + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: + return A.tty ? 0 : -59; + case 21519: + if (!A.tty) return -59; + var n = de.get(); + return (M[n >> 2] = 0), 0; + case 21520: + return A.tty ? -28 : -59; + case 21531: + n = de.get(); + return pe.ioctl(A, t, n); + case 21523: + case 21524: + return A.tty ? 0 : -59; + default: + _('bad ioctl syscall ' + t); + } + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + t: function (e, t, r) { + de.varargs = r; + try { + var A = de.getStr(e), + n = de.get(); + return pe.open(A, t, n).fd; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + s: function (e, t, r) { + try { + var A = de.getStreamFromFD(e); + return pe.read(A, N, t, r); + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + j: function (e, t) { + try { + return ( + (e = de.getStr(e)), (t = de.getStr(t)), pe.rename(e, t), 0 + ); + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + u: function (e) { + try { + return (e = de.getStr(e)), pe.rmdir(e), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + e: function (e, t) { + try { + return (e = de.getStr(e)), de.doStat(pe.stat, e, t); + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + i: function (e) { + try { + return (e = de.getStr(e)), pe.unlink(e), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), + -e.errno + ); + } + }, + v: function (e, t, r) { + F.copyWithin(e, t, t + r); + }, + w: function (e) { + e >>>= 0; + var t = F.length; + if (e > 2147483648) return !1; + for (var r, A, n = 1; n <= 4; n *= 2) { + var o = t * (1 + 0.2 / n); + if ( + ((o = Math.min(o, e + 100663296)), + Ce( + Math.min( + 2147483648, + ((r = Math.max(16777216, e, o)) % (A = 65536) > 0 && + (r += A - (r % A)), + r) + ) + )) + ) + return !0; + } + return !1; + }, + h: function (e) { + try { + var t = de.getStreamFromFD(e); + return pe.close(t), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), e.errno + ); + } + }, + k: function (e, t) { + try { + var r = de.getStreamFromFD(e), + A = r.tty + ? 2 + : pe.isDir(r.mode) + ? 3 + : pe.isLink(r.mode) + ? 7 + : 4; + return (N[t >> 0] = A), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), e.errno + ); + } + }, + p: function (e, t, r, A) { + try { + var n = de.getStreamFromFD(e), + o = de.doReadv(n, t, r); + return (M[A >> 2] = o), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), e.errno + ); + } + }, + n: function (e, t, r, A, n) { + try { + var o = de.getStreamFromFD(e), + i = 4294967296 * r + (t >>> 0); + return i <= -9007199254740992 || i >= 9007199254740992 + ? -61 + : (pe.llseek(o, i, A), + (te = [ + o.position >>> 0, + ((ee = o.position), + +Y(ee) >= 1 + ? ee > 0 + ? (0 | J(+H(ee / 4294967296), 4294967295)) >>> 0 + : ~~+G((ee - +(~~ee >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (M[n >> 2] = te[0]), + (M[(n + 4) >> 2] = te[1]), + o.getdents && 0 === i && 0 === A && (o.getdents = null), + 0); + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), e.errno + ); + } + }, + f: function (e, t, r, A) { + try { + var n = de.getStreamFromFD(e), + o = de.doWritev(n, t, r); + return (M[A >> 2] = o), 0; + } catch (e) { + return ( + (void 0 !== pe && e instanceof pe.ErrnoError) || _(e), e.errno + ); + } + }, + a: C, + c: function (e) { + 0 | e; + }, + d: function (e) { + var t = (Date.now() / 1e3) | 0; + return e && (M[e >> 2] = t), t; + }, + o: function (e) { + !(function e() { + if (!e.called) { + (e.called = !0), + (M[Ke() >> 2] = 60 * new Date().getTimezoneOffset()); + var t = new Date().getFullYear(), + r = new Date(t, 0, 1), + A = new Date(t, 6, 1); + M[Fe() >> 2] = Number( + r.getTimezoneOffset() != A.getTimezoneOffset() + ); + var n = a(r), + o = a(A), + i = S(n), + s = S(o); + A.getTimezoneOffset() < r.getTimezoneOffset() + ? ((M[Ne() >> 2] = i), (M[(Ne() + 4) >> 2] = s)) + : ((M[Ne() >> 2] = s), (M[(Ne() + 4) >> 2] = i)); + } + function a(e) { + var t = e.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return t ? t[1] : 'GMT'; + } + })(); + var t = Date.UTC( + M[(e + 20) >> 2] + 1900, + M[(e + 16) >> 2], + M[(e + 12) >> 2], + M[(e + 8) >> 2], + M[(e + 4) >> 2], + M[e >> 2], + 0 + ), + r = new Date(t); + M[(e + 24) >> 2] = r.getUTCDay(); + var A = Date.UTC(r.getUTCFullYear(), 0, 1, 0, 0, 0, 0), + n = ((r.getTime() - A) / 864e5) | 0; + return (M[(e + 28) >> 2] = n), (r.getTime() / 1e3) | 0; + }, + }, + ve = (function () { + var e = { a: be }; + function t(e, t) { + var r = e.exports; + (o.asm = r), X(); + } + if ((V(), o.instantiateWasm)) + try { + return o.instantiateWasm(e, t); + } catch (e) { + return ( + p('Module.instantiateWasm callback failed with error: ' + e), + !1 + ); + } + return ( + (function () { + var r, A, n; + try { + (n = (function () { + try { + if (d) return new Uint8Array(d); + var e = Qe(re); + if (e) return e; + if (a) return a(re); + throw "sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)"; + } catch (e) { + _(e); + } + })()), + (A = new WebAssembly.Module(n)), + (r = new WebAssembly.Instance(A, e)); + } catch (e) { + var o = e.toString(); + throw ( + (p('failed to compile wasm module: ' + o), + (o.indexOf('imported Memory') >= 0 || + o.indexOf('memory import') >= 0) && + p( + 'Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time).' + ), + e) + ); + } + t(r); + })(), + o.asm + ); + })(), + Se = (o.___wasm_call_ctors = ve.x), + ke = + ((o._zipstruct_stat = ve.y), + (o._zipstruct_statS = ve.z), + (o._zipstruct_stat_name = ve.A), + (o._zipstruct_stat_index = ve.B), + (o._zipstruct_stat_size = ve.C), + (o._zipstruct_stat_mtime = ve.D), + (o._zipstruct_error = ve.E), + (o._zipstruct_errorS = ve.F), + (o._zipstruct_error_code_zip = ve.G), + (o._zipstruct_stat_comp_size = ve.H), + (o._zipstruct_stat_comp_method = ve.I), + (o._zip_close = ve.J), + (o._zip_delete = ve.K), + (o._zip_dir_add = ve.L), + (o._zip_discard = ve.M), + (o._zip_error_init_with_code = ve.N), + (o._zip_get_error = ve.O), + (o._zip_file_get_error = ve.P), + (o._zip_error_strerror = ve.Q), + (o._zip_fclose = ve.R), + (o._zip_file_add = ve.S), + (o._zip_file_get_external_attributes = ve.T), + (o._zip_file_set_external_attributes = ve.U), + (o._zip_file_set_mtime = ve.V), + (o._zip_fopen = ve.W), + (o._zip_fopen_index = ve.X), + (o._zip_fread = ve.Y), + (o._zip_get_name = ve.Z), + (o._zip_get_num_entries = ve._), + (o._zip_name_locate = ve.$), + (o._zip_open = ve.aa), + (o._zip_open_from_source = ve.ba), + (o._zip_set_file_compression = ve.ca), + (o._zip_source_buffer = ve.da), + (o._zip_source_buffer_create = ve.ea), + (o._zip_source_close = ve.fa), + (o._zip_source_error = ve.ga), + (o._zip_source_free = ve.ha), + (o._zip_source_keep = ve.ia), + (o._zip_source_open = ve.ja), + (o._zip_source_read = ve.ka), + (o._zip_source_seek = ve.la), + (o._zip_source_set_mtime = ve.ma), + (o._zip_source_tell = ve.na), + (o._zip_stat = ve.oa), + (o._zip_stat_index = ve.pa), + (o._zip_ext_count_symlinks = ve.qa), + (o.___errno_location = ve.ra)), + Ne = (o.__get_tzname = ve.sa), + Fe = (o.__get_daylight = ve.ta), + Ke = (o.__get_timezone = ve.ua), + Me = (o.stackSave = ve.va), + Re = (o.stackRestore = ve.wa), + xe = (o.stackAlloc = ve.xa), + Le = (o._malloc = ve.ya); + o._free = ve.za; + function Pe(e) { + function t() { + De || + ((De = !0), + (o.calledRun = !0), + I || + (!0, + o.noFSInit || pe.init.initialized || pe.init(), + ce.init(), + Ae(U), + (pe.ignorePermissions = !1), + Ae(T), + o.onRuntimeInitialized && o.onRuntimeInitialized(), + (function () { + if (o.postRun) + for ( + 'function' == typeof o.postRun && + (o.postRun = [o.postRun]); + o.postRun.length; + + ) + (e = o.postRun.shift()), j.unshift(e); + var e; + Ae(j); + })())); + } + (e = e || l), + q > 0 || + (!(function () { + if (o.preRun) + for ( + 'function' == typeof o.preRun && (o.preRun = [o.preRun]); + o.preRun.length; + + ) + (e = o.preRun.shift()), O.unshift(e); + var e; + Ae(O); + })(), + q > 0 || + (o.setStatus + ? (o.setStatus('Running...'), + setTimeout(function () { + setTimeout(function () { + o.setStatus(''); + }, 1), + t(); + }, 1)) + : t())); + } + if ( + ((o.cwrap = function (e, t, r, A) { + var n = (r = r || []).every(function (e) { + return 'number' === e; + }); + return 'string' !== t && n && !A + ? B(e) + : function () { + return y(e, t, r, arguments); + }; + }), + (o.getValue = function (e, t, r) { + switch ( + ('*' === (t = t || 'i8').charAt(t.length - 1) && (t = 'i32'), t) + ) { + case 'i1': + case 'i8': + return N[e >> 0]; + case 'i16': + return K[e >> 1]; + case 'i32': + case 'i64': + return M[e >> 2]; + case 'float': + return R[e >> 2]; + case 'double': + return x[e >> 3]; + default: + _('invalid type for getValue: ' + t); + } + return null; + }), + (W = function e() { + De || Pe(), De || (W = e); + }), + (o.run = Pe), + o.preInit) + ) + for ( + 'function' == typeof o.preInit && (o.preInit = [o.preInit]); + o.preInit.length > 0; + + ) + o.preInit.pop()(); + Pe(); + }, + 98261: (e) => { + 'use strict'; + function t(e, r, A, n) { + (this.message = e), + (this.expected = r), + (this.found = A), + (this.location = n), + (this.name = 'SyntaxError'), + 'function' == typeof Error.captureStackTrace && + Error.captureStackTrace(this, t); + } + !(function (e, t) { + function r() { + this.constructor = e; + } + (r.prototype = t.prototype), (e.prototype = new r()); + })(t, Error), + (t.buildMessage = function (e, t) { + var r = { + literal: function (e) { + return `"${n(e.text)}"`; + }, + class: function (e) { + var t, + r = ''; + for (t = 0; t < e.parts.length; t++) + r += + e.parts[t] instanceof Array + ? `${o(e.parts[t][0])}-${o(e.parts[t][1])}` + : o(e.parts[t]); + return `[${e.inverted ? '^' : ''}${r}]`; + }, + any: function (e) { + return 'any character'; + }, + end: function (e) { + return 'end of input'; + }, + other: function (e) { + return e.description; + }, + }; + function A(e) { + return e.charCodeAt(0).toString(16).toUpperCase(); + } + function n(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + function o(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/\]/g, '\\]') + .replace(/\^/g, '\\^') + .replace(/-/g, '\\-') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + return `Expected ${(function (e) { + var t, + A, + n, + o = new Array(e.length); + for (t = 0; t < e.length; t++) o[t] = ((n = e[t]), r[n.type](n)); + if ((o.sort(), o.length > 0)) { + for (t = 1, A = 1; t < o.length; t++) + o[t - 1] !== o[t] && ((o[A] = o[t]), A++); + o.length = A; + } + switch (o.length) { + case 1: + return o[0]; + case 2: + return `${o[0]} or ${o[1]}`; + default: + return `${o.slice(0, -1).join(', ')}, or ${o[o.length - 1]}`; + } + })(e)} but ${(function (e) { + return e ? `"${n(e)}"` : 'end of input'; + })(t)} found.`; + }), + (e.exports = { + SyntaxError: t, + parse: function (e, r) { + r = void 0 !== r ? r : {}; + var A, + n = {}, + o = { resolution: D }, + i = D, + s = E('/', !1), + a = E('@', !1), + c = function () { + return e.substring(d, p); + }, + g = /^[^\/@]/, + l = B(['/', '@'], !0, !1), + u = /^[^\/]/, + h = B(['/'], !0, !1), + p = 0, + d = 0, + C = [{ line: 1, column: 1 }], + f = 0, + I = []; + if ('startRule' in r) { + if (!(r.startRule in o)) + throw new Error( + `Can't start parsing from rule "${r.startRule}".` + ); + i = o[r.startRule]; + } + function E(e, t) { + return { type: 'literal', text: e, ignoreCase: t }; + } + function B(e, t, r) { + return { type: 'class', parts: e, inverted: t, ignoreCase: r }; + } + function y(t) { + var r, + A = C[t]; + if (A) return A; + for (r = t - 1; !C[r]; ) r--; + for (A = { line: (A = C[r]).line, column: A.column }; r < t; ) + 10 === e.charCodeAt(r) + ? (A.line++, (A.column = 1)) + : A.column++, + r++; + return (C[t] = A), A; + } + function m(e, t) { + var r = y(e), + A = y(t); + return { + start: { offset: e, line: r.line, column: r.column }, + end: { offset: t, line: A.line, column: A.column }, + }; + } + function w(e) { + p < f || (p > f && ((f = p), (I = [])), I.push(e)); + } + function Q(e, r, A) { + return new t(t.buildMessage(e, r), e, r, A); + } + function D() { + var t, r, A, o; + return ( + (t = p), + (r = b()) !== n + ? (47 === e.charCodeAt(p) + ? ((A = '/'), p++) + : ((A = n), w(s)), + A !== n && (o = b()) !== n + ? ((d = t), (t = r = { from: r, descriptor: o })) + : ((p = t), (t = n))) + : ((p = t), (t = n)), + t === n && + ((t = p), + (r = b()) !== n && + ((d = t), + (r = (function (e) { + return { descriptor: e }; + })(r))), + (t = r)), + t + ); + } + function b() { + var t, r, A, o; + return ( + (t = p), + (r = v()) !== n + ? (64 === e.charCodeAt(p) + ? ((A = '@'), p++) + : ((A = n), w(a)), + A !== n && + (o = (function () { + var t, r, A; + (t = p), + (r = []), + u.test(e.charAt(p)) + ? ((A = e.charAt(p)), p++) + : ((A = n), w(h)); + if (A !== n) + for (; A !== n; ) + r.push(A), + u.test(e.charAt(p)) + ? ((A = e.charAt(p)), p++) + : ((A = n), w(h)); + else r = n; + r !== n && ((d = t), (r = c())); + return (t = r); + })()) !== n + ? ((d = t), (t = r = { fullName: r, description: o })) + : ((p = t), (t = n))) + : ((p = t), (t = n)), + t === n && + ((t = p), + (r = v()) !== n && + ((d = t), + (r = (function (e) { + return { fullName: e }; + })(r))), + (t = r)), + t + ); + } + function v() { + var t, r, A; + return ( + (t = p), + 64 === e.charCodeAt(p) ? ((r = '@'), p++) : ((r = n), w(a)), + r !== n && S() !== n + ? (47 === e.charCodeAt(p) + ? ((A = '/'), p++) + : ((A = n), w(s)), + A !== n && S() !== n + ? ((d = t), (t = r = c())) + : ((p = t), (t = n))) + : ((p = t), (t = n)), + t === n && + ((t = p), (r = S()) !== n && ((d = t), (r = c())), (t = r)), + t + ); + } + function S() { + var t, r, A; + if ( + ((t = p), + (r = []), + g.test(e.charAt(p)) + ? ((A = e.charAt(p)), p++) + : ((A = n), w(l)), + A !== n) + ) + for (; A !== n; ) + r.push(A), + g.test(e.charAt(p)) + ? ((A = e.charAt(p)), p++) + : ((A = n), w(l)); + else r = n; + return r !== n && ((d = t), (r = c())), (t = r); + } + if ((A = i()) !== n && p === e.length) return A; + throw ( + (A !== n && p < e.length && w({ type: 'end' }), + Q( + I, + f < e.length ? e.charAt(f) : null, + f < e.length ? m(f, f + 1) : m(f, f) + )) + ); + }, + }); + }, + 92962: (e) => { + 'use strict'; + function t(e, r, A, n) { + (this.message = e), + (this.expected = r), + (this.found = A), + (this.location = n), + (this.name = 'SyntaxError'), + 'function' == typeof Error.captureStackTrace && + Error.captureStackTrace(this, t); + } + !(function (e, t) { + function r() { + this.constructor = e; + } + (r.prototype = t.prototype), (e.prototype = new r()); + })(t, Error), + (t.buildMessage = function (e, t) { + var r = { + literal: function (e) { + return '"' + n(e.text) + '"'; + }, + class: function (e) { + var t, + r = ''; + for (t = 0; t < e.parts.length; t++) + r += + e.parts[t] instanceof Array + ? o(e.parts[t][0]) + '-' + o(e.parts[t][1]) + : o(e.parts[t]); + return '[' + (e.inverted ? '^' : '') + r + ']'; + }, + any: function (e) { + return 'any character'; + }, + end: function (e) { + return 'end of input'; + }, + other: function (e) { + return e.description; + }, + }; + function A(e) { + return e.charCodeAt(0).toString(16).toUpperCase(); + } + function n(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + function o(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/\]/g, '\\]') + .replace(/\^/g, '\\^') + .replace(/-/g, '\\-') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + return ( + 'Expected ' + + (function (e) { + var t, + A, + n, + o = new Array(e.length); + for (t = 0; t < e.length; t++) + o[t] = ((n = e[t]), r[n.type](n)); + if ((o.sort(), o.length > 0)) { + for (t = 1, A = 1; t < o.length; t++) + o[t - 1] !== o[t] && ((o[A] = o[t]), A++); + o.length = A; + } + switch (o.length) { + case 1: + return o[0]; + case 2: + return o[0] + ' or ' + o[1]; + default: + return ( + o.slice(0, -1).join(', ') + ', or ' + o[o.length - 1] + ); + } + })(e) + + ' but ' + + (function (e) { + return e ? '"' + n(e) + '"' : 'end of input'; + })(t) + + ' found.' + ); + }), + (e.exports = { + SyntaxError: t, + parse: function (e, r) { + r = void 0 !== r ? r : {}; + var A, + n = {}, + o = { Start: fe }, + i = fe, + s = le(';', !1), + a = le('&&', !1), + c = le('||', !1), + g = le('|&', !1), + l = le('|', !1), + u = le('=', !1), + h = le('(', !1), + p = le(')', !1), + d = le('{', !1), + C = le('}', !1), + f = le('>>', !1), + I = le('>&', !1), + E = le('>', !1), + B = le('<<<', !1), + y = le('<&', !1), + m = le('<', !1), + w = le("'", !1), + Q = le('"', !1), + D = function (e) { + return { type: 'text', text: e }; + }, + b = le('\\', !1), + v = { type: 'any' }, + S = /^[^']/, + k = ue(["'"], !0, !1), + N = function (e) { + return e.join(''); + }, + F = /^[^$"]/, + K = ue(['$', '"'], !0, !1), + M = le('-', !1), + R = le('+', !1), + x = /^[0-9]/, + L = ue([['0', '9']], !1, !1), + P = le('.', !1), + O = le('*', !1), + U = le('/', !1), + T = le('$((', !1), + j = le('))', !1), + Y = le('$(', !1), + G = le('${', !1), + H = le(':-', !1), + J = le(':-}', !1), + q = function (e) { + return { name: e }; + }, + z = le('$', !1), + W = /^[a-zA-Z0-9_]/, + V = ue([['a', 'z'], ['A', 'Z'], ['0', '9'], '_'], !1, !1), + X = function () { + return e.substring(ie, oe); + }, + _ = /^[$@*?#a-zA-Z0-9_\-]/, + Z = ue( + [ + '$', + '@', + '*', + '?', + '#', + ['a', 'z'], + ['A', 'Z'], + ['0', '9'], + '_', + '-', + ], + !1, + !1 + ), + $ = /^[(){}<>$|&; \t"']/, + ee = ue( + [ + '(', + ')', + '{', + '}', + '<', + '>', + '$', + '|', + '&', + ';', + ' ', + '\t', + '"', + "'", + ], + !1, + !1 + ), + te = /^[<>&; \t"']/, + re = ue(['<', '>', '&', ';', ' ', '\t', '"', "'"], !1, !1), + Ae = /^[ \t]/, + ne = ue([' ', '\t'], !1, !1), + oe = 0, + ie = 0, + se = [{ line: 1, column: 1 }], + ae = 0, + ce = [], + ge = 0; + if ('startRule' in r) { + if (!(r.startRule in o)) + throw new Error( + 'Can\'t start parsing from rule "' + r.startRule + '".' + ); + i = o[r.startRule]; + } + function le(e, t) { + return { type: 'literal', text: e, ignoreCase: t }; + } + function ue(e, t, r) { + return { type: 'class', parts: e, inverted: t, ignoreCase: r }; + } + function he(t) { + var r, + A = se[t]; + if (A) return A; + for (r = t - 1; !se[r]; ) r--; + for (A = { line: (A = se[r]).line, column: A.column }; r < t; ) + 10 === e.charCodeAt(r) + ? (A.line++, (A.column = 1)) + : A.column++, + r++; + return (se[t] = A), A; + } + function pe(e, t) { + var r = he(e), + A = he(t); + return { + start: { offset: e, line: r.line, column: r.column }, + end: { offset: t, line: A.line, column: A.column }, + }; + } + function de(e) { + oe < ae || (oe > ae && ((ae = oe), (ce = [])), ce.push(e)); + } + function Ce(e, r, A) { + return new t(t.buildMessage(e, r), e, r, A); + } + function fe() { + var e, t; + return ( + (e = oe), + (t = Ie()) === n && (t = null), + t !== n && ((ie = e), (t = t || [])), + (e = t) + ); + } + function Ie() { + var e, t, r, A, o; + if (((e = oe), (t = Be()) !== n)) { + for (r = [], A = Te(); A !== n; ) r.push(A), (A = Te()); + r !== n && (A = Ee()) !== n + ? ((o = (function () { + var e, t, r, A, o; + (e = oe), (t = []), (r = Te()); + for (; r !== n; ) t.push(r), (r = Te()); + if (t !== n) + if ((r = Ie()) !== n) { + for (A = [], o = Te(); o !== n; ) + A.push(o), (o = Te()); + A !== n + ? ((ie = e), (e = t = r)) + : ((oe = e), (e = n)); + } else (oe = e), (e = n); + else (oe = e), (e = n); + return e; + })()) === n && (o = null), + o !== n + ? ((ie = e), (e = t = [t].concat(o || []))) + : ((oe = e), (e = n))) + : ((oe = e), (e = n)); + } else (oe = e), (e = n); + if (e === n) + if (((e = oe), (t = Be()) !== n)) { + for (r = [], A = Te(); A !== n; ) r.push(A), (A = Te()); + r !== n + ? ((A = Ee()) === n && (A = null), + A !== n + ? ((ie = e), + (e = t = (function (e, t) { + return [e]; + })(t))) + : ((oe = e), (e = n))) + : ((oe = e), (e = n)); + } else (oe = e), (e = n); + return e; + } + function Ee() { + var t; + return ( + 59 === e.charCodeAt(oe) + ? ((t = ';'), oe++) + : ((t = n), 0 === ge && de(s)), + t + ); + } + function Be() { + var t, r, A, o, i; + return ( + (t = oe), + (r = ye()) !== n + ? ((A = (function () { + var t, r, A, o, i, s, g; + (t = oe), (r = []), (A = Te()); + for (; A !== n; ) r.push(A), (A = Te()); + if (r !== n) + if ( + (A = (function () { + var t; + '&&' === e.substr(oe, 2) + ? ((t = '&&'), (oe += 2)) + : ((t = n), 0 === ge && de(a)); + t === n && + ('||' === e.substr(oe, 2) + ? ((t = '||'), (oe += 2)) + : ((t = n), 0 === ge && de(c))); + return t; + })()) !== n + ) { + for (o = [], i = Te(); i !== n; ) + o.push(i), (i = Te()); + if (o !== n) + if ((i = Be()) !== n) { + for (s = [], g = Te(); g !== n; ) + s.push(g), (g = Te()); + s !== n + ? ((ie = t), (t = r = { type: A, line: i })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + return t; + })()) === n && (A = null), + A !== n + ? ((ie = t), + (o = r), + (t = r = (i = A) + ? { chain: o, then: i } + : { chain: o })) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t + ); + } + function ye() { + var t, r, A, o, i; + return ( + (t = oe), + (r = (function () { + var t, r, A, o, i, s, a, c, g, l, u; + (t = oe), (r = []), (A = Te()); + for (; A !== n; ) r.push(A), (A = Te()); + if (r !== n) + if ( + (40 === e.charCodeAt(oe) + ? ((A = '('), oe++) + : ((A = n), 0 === ge && de(h)), + A !== n) + ) { + for (o = [], i = Te(); i !== n; ) o.push(i), (i = Te()); + if (o !== n) + if ((i = Ie()) !== n) { + for (s = [], a = Te(); a !== n; ) + s.push(a), (a = Te()); + if (s !== n) + if ( + (41 === e.charCodeAt(oe) + ? ((a = ')'), oe++) + : ((a = n), 0 === ge && de(p)), + a !== n) + ) { + for (c = [], g = Te(); g !== n; ) + c.push(g), (g = Te()); + if (c !== n) { + for (g = [], l = Qe(); l !== n; ) + g.push(l), (l = Qe()); + if (g !== n) { + for (l = [], u = Te(); u !== n; ) + l.push(u), (u = Te()); + l !== n + ? ((ie = t), + (t = r = { + type: 'subshell', + subshell: i, + args: g, + })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + if (t === n) { + for (t = oe, r = [], A = Te(); A !== n; ) + r.push(A), (A = Te()); + if (r !== n) + if ( + (123 === e.charCodeAt(oe) + ? ((A = '{'), oe++) + : ((A = n), 0 === ge && de(d)), + A !== n) + ) { + for (o = [], i = Te(); i !== n; ) + o.push(i), (i = Te()); + if (o !== n) + if ((i = Ie()) !== n) { + for (s = [], a = Te(); a !== n; ) + s.push(a), (a = Te()); + if (s !== n) + if ( + (125 === e.charCodeAt(oe) + ? ((a = '}'), oe++) + : ((a = n), 0 === ge && de(C)), + a !== n) + ) { + for (c = [], g = Te(); g !== n; ) + c.push(g), (g = Te()); + if (c !== n) { + for (g = [], l = Qe(); l !== n; ) + g.push(l), (l = Qe()); + if (g !== n) { + for (l = [], u = Te(); u !== n; ) + l.push(u), (u = Te()); + l !== n + ? ((ie = t), + (r = (function (e, t) { + return { + type: 'group', + group: e, + args: t, + }; + })(i, g)), + (t = r)) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + if (t === n) { + for (t = oe, r = [], A = Te(); A !== n; ) + r.push(A), (A = Te()); + if (r !== n) { + for (A = [], o = me(); o !== n; ) + A.push(o), (o = me()); + if (A !== n) { + for (o = [], i = Te(); i !== n; ) + o.push(i), (i = Te()); + if (o !== n) { + if (((i = []), (s = we()) !== n)) + for (; s !== n; ) i.push(s), (s = we()); + else i = n; + if (i !== n) { + for (s = [], a = Te(); a !== n; ) + s.push(a), (a = Te()); + s !== n + ? ((ie = t), + (r = (function (e, t) { + return { + type: 'command', + args: t, + envs: e, + }; + })(A, i)), + (t = r)) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + if (t === n) { + for (t = oe, r = [], A = Te(); A !== n; ) + r.push(A), (A = Te()); + if (r !== n) { + if (((A = []), (o = me()) !== n)) + for (; o !== n; ) A.push(o), (o = me()); + else A = n; + if (A !== n) { + for (o = [], i = Te(); i !== n; ) + o.push(i), (i = Te()); + o !== n + ? ((ie = t), + (t = r = { type: 'envs', envs: A })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + } else (oe = t), (t = n); + } + } + } + return t; + })()) !== n + ? ((A = (function () { + var t, r, A, o, i, s, a; + (t = oe), (r = []), (A = Te()); + for (; A !== n; ) r.push(A), (A = Te()); + if (r !== n) + if ( + (A = (function () { + var t; + '|&' === e.substr(oe, 2) + ? ((t = '|&'), (oe += 2)) + : ((t = n), 0 === ge && de(g)); + t === n && + (124 === e.charCodeAt(oe) + ? ((t = '|'), oe++) + : ((t = n), 0 === ge && de(l))); + return t; + })()) !== n + ) { + for (o = [], i = Te(); i !== n; ) + o.push(i), (i = Te()); + if (o !== n) + if ((i = ye()) !== n) { + for (s = [], a = Te(); a !== n; ) + s.push(a), (a = Te()); + s !== n + ? ((ie = t), (t = r = { type: A, chain: i })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + else (oe = t), (t = n); + return t; + })()) === n && (A = null), + A !== n + ? ((ie = t), + (o = r), + (t = r = (i = A) ? { ...o, then: i } : o)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t + ); + } + function me() { + var t, r, A, o, i, s; + if (((t = oe), (r = Le()) !== n)) + if ( + (61 === e.charCodeAt(oe) + ? ((A = '='), oe++) + : ((A = n), 0 === ge && de(u)), + A !== n) + ) + if ((o = be()) !== n) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n + ? ((ie = t), (t = r = { name: r, args: [o] })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + else (oe = t), (t = n); + if (t === n) + if (((t = oe), (r = Le()) !== n)) + if ( + (61 === e.charCodeAt(oe) + ? ((A = '='), oe++) + : ((A = n), 0 === ge && de(u)), + A !== n) + ) { + for (o = [], i = Te(); i !== n; ) o.push(i), (i = Te()); + o !== n + ? ((ie = t), + (t = r = (function (e) { + return { name: e, args: [] }; + })(r))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + return t; + } + function we() { + var e, t, r; + for (e = oe, t = [], r = Te(); r !== n; ) t.push(r), (r = Te()); + if ( + (t !== n && (r = Qe()) !== n + ? ((ie = e), (e = t = r)) + : ((oe = e), (e = n)), + e === n) + ) { + for (e = oe, t = [], r = Te(); r !== n; ) + t.push(r), (r = Te()); + t !== n && (r = De()) !== n + ? ((ie = e), (e = t = r)) + : ((oe = e), (e = n)); + } + return e; + } + function Qe() { + var t, r, A, o; + for (t = oe, r = [], A = Te(); A !== n; ) r.push(A), (A = Te()); + return ( + r !== n && + (A = (function () { + var t; + '>>' === e.substr(oe, 2) + ? ((t = '>>'), (oe += 2)) + : ((t = n), 0 === ge && de(f)); + t === n && + ('>&' === e.substr(oe, 2) + ? ((t = '>&'), (oe += 2)) + : ((t = n), 0 === ge && de(I)), + t === n && + (62 === e.charCodeAt(oe) + ? ((t = '>'), oe++) + : ((t = n), 0 === ge && de(E)), + t === n && + ('<<<' === e.substr(oe, 3) + ? ((t = '<<<'), (oe += 3)) + : ((t = n), 0 === ge && de(B)), + t === n && + ('<&' === e.substr(oe, 2) + ? ((t = '<&'), (oe += 2)) + : ((t = n), 0 === ge && de(y)), + t === n && + (60 === e.charCodeAt(oe) + ? ((t = '<'), oe++) + : ((t = n), 0 === ge && de(m))))))); + return t; + })()) !== n && + (o = De()) !== n + ? ((ie = t), + (t = r = { type: 'redirection', subtype: A, args: [o] })) + : ((oe = t), (t = n)), + t + ); + } + function De() { + var e, t, r; + for (e = oe, t = [], r = Te(); r !== n; ) t.push(r), (r = Te()); + return ( + t !== n && (r = be()) !== n + ? ((ie = e), (e = t = r)) + : ((oe = e), (e = n)), + e + ); + } + function be() { + var e, t, r, A; + if (((e = oe), (t = []), (r = ve()) !== n)) + for (; r !== n; ) t.push(r), (r = ve()); + else t = n; + return ( + t !== n && + ((ie = e), + (A = t), + (t = { type: 'argument', segments: [].concat(...A) })), + (e = t) + ); + } + function ve() { + var t, r; + return ( + (t = oe), + (r = (function () { + var t, r, A, o; + (t = oe), + 39 === e.charCodeAt(oe) + ? ((r = "'"), oe++) + : ((r = n), 0 === ge && de(w)); + r !== n && + (A = (function () { + var t, r, A, o, i; + (t = oe), + (r = []), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)); + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)); + A === n && + (S.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(k))); + for (; A !== n; ) + r.push(A), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)), + A === n && + (S.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(k))); + r !== n && ((ie = t), (r = N(r))); + return (t = r); + })()) !== n + ? (39 === e.charCodeAt(oe) + ? ((o = "'"), oe++) + : ((o = n), 0 === ge && de(w)), + o !== n + ? ((ie = t), + (r = (function (e) { + return [{ type: 'text', text: e }]; + })(A)), + (t = r)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)); + return t; + })()) !== n && ((ie = t), (r = r)), + (t = r) === n && + ((t = oe), + (r = (function () { + var t, r, A, o; + (t = oe), + 34 === e.charCodeAt(oe) + ? ((r = '"'), oe++) + : ((r = n), 0 === ge && de(Q)); + if (r !== n) { + for (A = [], o = Se(); o !== n; ) A.push(o), (o = Se()); + A !== n + ? (34 === e.charCodeAt(oe) + ? ((o = '"'), oe++) + : ((o = n), 0 === ge && de(Q)), + o !== n + ? ((ie = t), (t = r = A)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + return t; + })()) !== n && ((ie = t), (r = r)), + (t = r) === n && + ((t = oe), + (r = (function () { + var e, t, r; + if (((e = oe), (t = []), (r = ke()) !== n)) + for (; r !== n; ) t.push(r), (r = ke()); + else t = n; + t !== n && ((ie = e), (t = t)); + return (e = t); + })()) !== n && ((ie = t), (r = r)), + (t = r))), + t + ); + } + function Se() { + var t, r, A; + return ( + (t = oe), + (r = Me()) !== n && + ((ie = t), + (r = { type: 'arithmetic', arithmetic: r, quoted: !0 })), + (t = r) === n && + ((t = oe), + (r = Re()) !== n && + ((ie = t), (r = { type: 'shell', shell: r, quoted: !0 })), + (t = r) === n && + ((t = oe), + (r = xe()) !== n && + ((ie = t), + (A = r), + (r = { type: 'variable', ...A, quoted: !0 })), + (t = r) === n && + ((t = oe), + (r = (function () { + var t, r, A, o, i; + (t = oe), + (r = []), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)); + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)); + A === n && + (F.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(K))); + if (A !== n) + for (; A !== n; ) + r.push(A), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)), + A === n && + (F.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(K))); + else r = n; + r !== n && ((ie = t), (r = N(r))); + return (t = r); + })()) !== n && ((ie = t), (r = D(r))), + (t = r)))), + t + ); + } + function ke() { + var t, A, o; + return ( + (t = oe), + (A = Me()) !== n && + ((ie = t), + (A = { type: 'arithmetic', arithmetic: A, quoted: !1 })), + (t = A) === n && + ((t = oe), + (A = Re()) !== n && + ((ie = t), (A = { type: 'shell', shell: A, quoted: !1 })), + (t = A) === n && + ((t = oe), + (A = xe()) !== n && + ((ie = t), + (o = A), + (A = { type: 'variable', ...o, quoted: !1 })), + (t = A) === n && + ((t = oe), + (A = (function () { + var t, A; + (t = oe), + (A = (function () { + var t, r, A, o, i; + (t = oe), + (r = []), + (A = oe), + (o = oe), + ge++, + (i = Ue()), + ge--, + i === n ? (o = void 0) : ((oe = o), (o = n)); + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)); + if (A !== n) + for (; A !== n; ) + r.push(A), + (A = oe), + (o = oe), + ge++, + (i = Ue()), + ge--, + i === n + ? (o = void 0) + : ((oe = o), (o = n)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)); + else r = n; + r !== n && ((ie = t), (r = N(r))); + return (t = r); + })()) !== n + ? ((ie = oe), + (o = A), + (r.isGlobPattern(o) ? void 0 : n) !== n + ? ((ie = t), (t = A = A)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)); + var o; + return t; + })()) !== n && + ((ie = t), (A = { type: 'glob', pattern: A })), + (t = A) === n && + ((t = oe), + (A = (function () { + var t, r, A, o, i; + (t = oe), + (r = []), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)); + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)); + A === n && + ((A = oe), + (o = oe), + ge++, + (i = Oe()), + ge--, + i === n ? (o = void 0) : ((oe = o), (o = n)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n))); + if (A !== n) + for (; A !== n; ) + r.push(A), + (A = oe), + 92 === e.charCodeAt(oe) + ? ((o = '\\'), oe++) + : ((o = n), 0 === ge && de(b)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n)), + A === n && + ((A = oe), + (o = oe), + ge++, + (i = Oe()), + ge--, + i === n + ? (o = void 0) + : ((oe = o), (o = n)), + o !== n + ? (e.length > oe + ? ((i = e.charAt(oe)), oe++) + : ((i = n), 0 === ge && de(v)), + i !== n + ? ((ie = A), (A = o = i)) + : ((oe = A), (A = n))) + : ((oe = A), (A = n))); + else r = n; + r !== n && ((ie = t), (r = N(r))); + return (t = r); + })()) !== n && ((ie = t), (A = D(A))), + (t = A))))), + t + ); + } + function Ne() { + var t, r, A, o, i, s, a, c; + if ( + ((t = oe), + 45 === e.charCodeAt(oe) + ? ((r = '-'), oe++) + : ((r = n), 0 === ge && de(M)), + r === n && + (43 === e.charCodeAt(oe) + ? ((r = '+'), oe++) + : ((r = n), 0 === ge && de(R))), + r === n && (r = null), + r !== n) + ) { + if ( + ((A = []), + x.test(e.charAt(oe)) + ? ((o = e.charAt(oe)), oe++) + : ((o = n), 0 === ge && de(L)), + o !== n) + ) + for (; o !== n; ) + A.push(o), + x.test(e.charAt(oe)) + ? ((o = e.charAt(oe)), oe++) + : ((o = n), 0 === ge && de(L)); + else A = n; + if (A !== n) + if ( + (46 === e.charCodeAt(oe) + ? ((o = '.'), oe++) + : ((o = n), 0 === ge && de(P)), + o !== n) + ) { + if ( + ((i = []), + x.test(e.charAt(oe)) + ? ((s = e.charAt(oe)), oe++) + : ((s = n), 0 === ge && de(L)), + s !== n) + ) + for (; s !== n; ) + i.push(s), + x.test(e.charAt(oe)) + ? ((s = e.charAt(oe)), oe++) + : ((s = n), 0 === ge && de(L)); + else i = n; + i !== n + ? ((ie = t), + (a = i), + (t = r = { + type: 'number', + value: + ('-' === r ? -1 : 1) * + parseFloat(A.join('') + '.' + a.join('')), + })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + if (t === n) { + if ( + ((t = oe), + 45 === e.charCodeAt(oe) + ? ((r = '-'), oe++) + : ((r = n), 0 === ge && de(M)), + r === n && + (43 === e.charCodeAt(oe) + ? ((r = '+'), oe++) + : ((r = n), 0 === ge && de(R))), + r === n && (r = null), + r !== n) + ) { + if ( + ((A = []), + x.test(e.charAt(oe)) + ? ((o = e.charAt(oe)), oe++) + : ((o = n), 0 === ge && de(L)), + o !== n) + ) + for (; o !== n; ) + A.push(o), + x.test(e.charAt(oe)) + ? ((o = e.charAt(oe)), oe++) + : ((o = n), 0 === ge && de(L)); + else A = n; + A !== n + ? ((ie = t), + (t = r = (function (e, t) { + return { + type: 'number', + value: ('-' === e ? -1 : 1) * parseInt(t.join('')), + }; + })(r, A))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + if ( + t === n && + ((t = oe), + (r = xe()) !== n && + ((ie = t), (c = r), (r = { type: 'variable', ...c })), + (t = r) === n && + ((t = oe), + (r = Pe()) !== n && + ((ie = t), (r = { type: 'variable', name: r })), + (t = r) === n)) + ) + if ( + ((t = oe), + 40 === e.charCodeAt(oe) + ? ((r = '('), oe++) + : ((r = n), 0 === ge && de(h)), + r !== n) + ) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ((o = Ke()) !== n) { + for (i = [], s = Te(); s !== n; ) + i.push(s), (s = Te()); + i !== n + ? (41 === e.charCodeAt(oe) + ? ((s = ')'), oe++) + : ((s = n), 0 === ge && de(p)), + s !== n + ? ((ie = t), (t = r = o)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + } + return t; + } + function Fe() { + var t, r, A, o, i, s; + if (((t = oe), (r = Ne()) !== n)) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ( + (42 === e.charCodeAt(oe) + ? ((o = '*'), oe++) + : ((o = n), 0 === ge && de(O)), + o !== n) + ) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n && (s = Fe()) !== n + ? ((ie = t), + (t = r = { + type: 'multiplication', + left: r, + right: s, + })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + if (t === n) { + if (((t = oe), (r = Ne()) !== n)) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ( + (47 === e.charCodeAt(oe) + ? ((o = '/'), oe++) + : ((o = n), 0 === ge && de(U)), + o !== n) + ) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n && (s = Fe()) !== n + ? ((ie = t), + (t = r = (function (e, t) { + return { type: 'division', left: e, right: t }; + })(r, s))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + t === n && (t = Ne()); + } + return t; + } + function Ke() { + var t, r, A, o, i, s; + if (((t = oe), (r = Fe()) !== n)) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ( + (43 === e.charCodeAt(oe) + ? ((o = '+'), oe++) + : ((o = n), 0 === ge && de(R)), + o !== n) + ) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n && (s = Ke()) !== n + ? ((ie = t), + (t = r = { type: 'addition', left: r, right: s })) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + if (t === n) { + if (((t = oe), (r = Fe()) !== n)) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ( + (45 === e.charCodeAt(oe) + ? ((o = '-'), oe++) + : ((o = n), 0 === ge && de(M)), + o !== n) + ) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n && (s = Ke()) !== n + ? ((ie = t), + (t = r = (function (e, t) { + return { type: 'subtraction', left: e, right: t }; + })(r, s))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + t === n && (t = Fe()); + } + return t; + } + function Me() { + var t, r, A, o, i, s; + if ( + ((t = oe), + '$((' === e.substr(oe, 3) + ? ((r = '$(('), (oe += 3)) + : ((r = n), 0 === ge && de(T)), + r !== n) + ) { + for (A = [], o = Te(); o !== n; ) A.push(o), (o = Te()); + if (A !== n) + if ((o = Ke()) !== n) { + for (i = [], s = Te(); s !== n; ) i.push(s), (s = Te()); + i !== n + ? ('))' === e.substr(oe, 2) + ? ((s = '))'), (oe += 2)) + : ((s = n), 0 === ge && de(j)), + s !== n + ? ((ie = t), (t = r = o)) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)); + } else (oe = t), (t = n); + else (oe = t), (t = n); + } else (oe = t), (t = n); + return t; + } + function Re() { + var t, r, A, o; + return ( + (t = oe), + '$(' === e.substr(oe, 2) + ? ((r = '$('), (oe += 2)) + : ((r = n), 0 === ge && de(Y)), + r !== n && (A = Ie()) !== n + ? (41 === e.charCodeAt(oe) + ? ((o = ')'), oe++) + : ((o = n), 0 === ge && de(p)), + o !== n ? ((ie = t), (t = r = A)) : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t + ); + } + function xe() { + var t, r, A, o, i, s; + return ( + (t = oe), + '${' === e.substr(oe, 2) + ? ((r = '${'), (oe += 2)) + : ((r = n), 0 === ge && de(G)), + r !== n && (A = Pe()) !== n + ? (':-' === e.substr(oe, 2) + ? ((o = ':-'), (oe += 2)) + : ((o = n), 0 === ge && de(H)), + o !== n && + (i = (function () { + var e, t, r, A, o; + for (e = oe, t = [], r = Te(); r !== n; ) + t.push(r), (r = Te()); + if (t !== n) { + if (((r = []), (A = De()) !== n)) + for (; A !== n; ) r.push(A), (A = De()); + else r = n; + if (r !== n) { + for (A = [], o = Te(); o !== n; ) + A.push(o), (o = Te()); + A !== n + ? ((ie = e), (e = t = r)) + : ((oe = e), (e = n)); + } else (oe = e), (e = n); + } else (oe = e), (e = n); + return e; + })()) !== n + ? (125 === e.charCodeAt(oe) + ? ((s = '}'), oe++) + : ((s = n), 0 === ge && de(C)), + s !== n + ? ((ie = t), (t = r = { name: A, defaultValue: i })) + : ((oe = t), (t = n))) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t === n && + ((t = oe), + '${' === e.substr(oe, 2) + ? ((r = '${'), (oe += 2)) + : ((r = n), 0 === ge && de(G)), + r !== n && (A = Pe()) !== n + ? (':-}' === e.substr(oe, 3) + ? ((o = ':-}'), (oe += 3)) + : ((o = n), 0 === ge && de(J)), + o !== n + ? ((ie = t), + (t = r = (function (e) { + return { name: e, defaultValue: [] }; + })(A))) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t === n && + ((t = oe), + '${' === e.substr(oe, 2) + ? ((r = '${'), (oe += 2)) + : ((r = n), 0 === ge && de(G)), + r !== n && (A = Pe()) !== n + ? (125 === e.charCodeAt(oe) + ? ((o = '}'), oe++) + : ((o = n), 0 === ge && de(C)), + o !== n + ? ((ie = t), (t = r = q(A))) + : ((oe = t), (t = n))) + : ((oe = t), (t = n)), + t === n && + ((t = oe), + 36 === e.charCodeAt(oe) + ? ((r = '$'), oe++) + : ((r = n), 0 === ge && de(z)), + r !== n && (A = Pe()) !== n + ? ((ie = t), (t = r = q(A))) + : ((oe = t), (t = n))))), + t + ); + } + function Le() { + var t, r, A; + if ( + ((t = oe), + (r = []), + W.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(V)), + A !== n) + ) + for (; A !== n; ) + r.push(A), + W.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(V)); + else r = n; + return r !== n && ((ie = t), (r = X())), (t = r); + } + function Pe() { + var t, r, A; + if ( + ((t = oe), + (r = []), + _.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(Z)), + A !== n) + ) + for (; A !== n; ) + r.push(A), + _.test(e.charAt(oe)) + ? ((A = e.charAt(oe)), oe++) + : ((A = n), 0 === ge && de(Z)); + else r = n; + return r !== n && ((ie = t), (r = X())), (t = r); + } + function Oe() { + var t; + return ( + $.test(e.charAt(oe)) + ? ((t = e.charAt(oe)), oe++) + : ((t = n), 0 === ge && de(ee)), + t + ); + } + function Ue() { + var t; + return ( + te.test(e.charAt(oe)) + ? ((t = e.charAt(oe)), oe++) + : ((t = n), 0 === ge && de(re)), + t + ); + } + function Te() { + var t, r; + if ( + ((t = []), + Ae.test(e.charAt(oe)) + ? ((r = e.charAt(oe)), oe++) + : ((r = n), 0 === ge && de(ne)), + r !== n) + ) + for (; r !== n; ) + t.push(r), + Ae.test(e.charAt(oe)) + ? ((r = e.charAt(oe)), oe++) + : ((r = n), 0 === ge && de(ne)); + else t = n; + return t; + } + if ((A = i()) !== n && oe === e.length) return A; + throw ( + (A !== n && oe < e.length && de({ type: 'end' }), + Ce( + ce, + ae < e.length ? e.charAt(ae) : null, + ae < e.length ? pe(ae, ae + 1) : pe(ae, ae) + )) + ); + }, + }); + }, + 85443: (e) => { + 'use strict'; + function t(e, r, A, n) { + (this.message = e), + (this.expected = r), + (this.found = A), + (this.location = n), + (this.name = 'SyntaxError'), + 'function' == typeof Error.captureStackTrace && + Error.captureStackTrace(this, t); + } + !(function (e, t) { + function r() { + this.constructor = e; + } + (r.prototype = t.prototype), (e.prototype = new r()); + })(t, Error), + (t.buildMessage = function (e, t) { + var r = { + literal: function (e) { + return `"${n(e.text)}"`; + }, + class: function (e) { + var t, + r = ''; + for (t = 0; t < e.parts.length; t++) + r += + e.parts[t] instanceof Array + ? `${o(e.parts[t][0])}-${o(e.parts[t][1])}` + : o(e.parts[t]); + return `[${e.inverted ? '^' : ''}${r}]`; + }, + any: function (e) { + return 'any character'; + }, + end: function (e) { + return 'end of input'; + }, + other: function (e) { + return e.description; + }, + }; + function A(e) { + return e.charCodeAt(0).toString(16).toUpperCase(); + } + function n(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/"/g, '\\"') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + function o(e) { + return e + .replace(/\\/g, '\\\\') + .replace(/\]/g, '\\]') + .replace(/\^/g, '\\^') + .replace(/-/g, '\\-') + .replace(/\0/g, '\\0') + .replace(/\t/g, '\\t') + .replace(/\n/g, '\\n') + .replace(/\r/g, '\\r') + .replace(/[\x00-\x0F]/g, function (e) { + return '\\x0' + A(e); + }) + .replace(/[\x10-\x1F\x7F-\x9F]/g, function (e) { + return '\\x' + A(e); + }); + } + return `Expected ${(function (e) { + var t, + A, + n, + o = new Array(e.length); + for (t = 0; t < e.length; t++) o[t] = ((n = e[t]), r[n.type](n)); + if ((o.sort(), o.length > 0)) { + for (t = 1, A = 1; t < o.length; t++) + o[t - 1] !== o[t] && ((o[A] = o[t]), A++); + o.length = A; + } + switch (o.length) { + case 1: + return o[0]; + case 2: + return `${o[0]} or ${o[1]}`; + default: + return `${o.slice(0, -1).join(', ')}, or ${o[o.length - 1]}`; + } + })(e)} but ${(function (e) { + return e ? `"${n(e)}"` : 'end of input'; + })(t)} found.`; + }), + (e.exports = { + SyntaxError: t, + parse: function (e, r) { + r = void 0 !== r ? r : {}; + var A, + n = {}, + o = { Start: le }, + i = le, + s = ne('-', !1), + a = ne('#', !1), + c = { type: 'any' }, + g = ne(':', !1), + l = function (e, t) { + return { [e]: t }; + }, + u = ne(',', !1), + h = function (e, t) { + return t; + }, + p = ie('correct indentation'), + d = ne(' ', !1), + C = ie('pseudostring'), + f = /^[^\r\n\t ?:,\][{}#&*!|>'"%@`\-]/, + I = oe( + [ + '\r', + '\n', + '\t', + ' ', + '?', + ':', + ',', + ']', + '[', + '{', + '}', + '#', + '&', + '*', + '!', + '|', + '>', + "'", + '"', + '%', + '@', + '`', + '-', + ], + !0, + !1 + ), + E = /^[^\r\n\t ,\][{}:#"']/, + B = oe( + [ + '\r', + '\n', + '\t', + ' ', + ',', + ']', + '[', + '{', + '}', + ':', + '#', + '"', + "'", + ], + !0, + !1 + ), + y = function () { + return Ae().replace(/^ *| *$/g, ''); + }, + m = ne('--', !1), + w = /^[a-zA-Z\/0-9]/, + Q = oe([['a', 'z'], ['A', 'Z'], '/', ['0', '9']], !1, !1), + D = /^[^\r\n\t :,]/, + b = oe(['\r', '\n', '\t', ' ', ':', ','], !0, !1), + v = ne('null', !1), + S = ne('true', !1), + k = ne('false', !1), + N = ie('string'), + F = ne('"', !1), + K = /^[^"\\\0-\x1F\x7F]/, + M = oe(['"', '\\', ['\0', ''], ''], !0, !1), + R = ne('\\"', !1), + x = ne('\\\\', !1), + L = ne('\\/', !1), + P = ne('\\b', !1), + O = ne('\\f', !1), + U = ne('\\n', !1), + T = ne('\\r', !1), + j = ne('\\t', !1), + Y = ne('\\u', !1), + G = /^[0-9a-fA-F]/, + H = oe( + [ + ['0', '9'], + ['a', 'f'], + ['A', 'F'], + ], + !1, + !1 + ), + J = ie('blank space'), + q = /^[ \t]/, + z = oe([' ', '\t'], !1, !1), + W = + (ie('white space'), + oe([' ', '\t', '\n', '\r'], !1, !1), + ne('\r\n', !1)), + V = ne('\n', !1), + X = ne('\r', !1), + _ = 0, + Z = 0, + $ = [{ line: 1, column: 1 }], + ee = 0, + te = [], + re = 0; + if ('startRule' in r) { + if (!(r.startRule in o)) + throw new Error( + `Can't start parsing from rule "${r.startRule}".` + ); + i = o[r.startRule]; + } + function Ae() { + return e.substring(Z, _); + } + function ne(e, t) { + return { type: 'literal', text: e, ignoreCase: t }; + } + function oe(e, t, r) { + return { type: 'class', parts: e, inverted: t, ignoreCase: r }; + } + function ie(e) { + return { type: 'other', description: e }; + } + function se(t) { + var r, + A = $[t]; + if (A) return A; + for (r = t - 1; !$[r]; ) r--; + for (A = { line: (A = $[r]).line, column: A.column }; r < t; ) + 10 === e.charCodeAt(r) + ? (A.line++, (A.column = 1)) + : A.column++, + r++; + return ($[t] = A), A; + } + function ae(e, t) { + var r = se(e), + A = se(t); + return { + start: { offset: e, line: r.line, column: r.column }, + end: { offset: t, line: A.line, column: A.column }, + }; + } + function ce(e) { + _ < ee || (_ > ee && ((ee = _), (te = [])), te.push(e)); + } + function ge(e, r, A) { + return new t(t.buildMessage(e, r), e, r, A); + } + function le() { + return he(); + } + function ue() { + var t, r, A; + return ( + (t = _), + Ce() !== n + ? (45 === e.charCodeAt(_) + ? ((r = '-'), _++) + : ((r = n), 0 === re && ce(s)), + r !== n && be() !== n && (A = de()) !== n + ? ((Z = t), (t = A)) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)), + t + ); + } + function he() { + var e, t, r, A; + for (e = _, t = [], r = pe(); r !== n; ) t.push(r), (r = pe()); + return ( + t !== n && ((Z = e), (A = t), (t = Object.assign({}, ...A))), + (e = t) + ); + } + function pe() { + var t, r, A, o, i, s, p, d, C, f, I, E; + if (((t = _), (r = be()) === n && (r = null), r !== n)) { + if ( + ((A = _), + 35 === e.charCodeAt(_) + ? ((o = '#'), _++) + : ((o = n), 0 === re && ce(a)), + o !== n) + ) { + if ( + ((i = []), + (s = _), + (p = _), + re++, + (d = Se()), + re--, + d === n ? (p = void 0) : ((_ = p), (p = n)), + p !== n + ? (e.length > _ + ? ((d = e.charAt(_)), _++) + : ((d = n), 0 === re && ce(c)), + d !== n ? (s = p = [p, d]) : ((_ = s), (s = n))) + : ((_ = s), (s = n)), + s !== n) + ) + for (; s !== n; ) + i.push(s), + (s = _), + (p = _), + re++, + (d = Se()), + re--, + d === n ? (p = void 0) : ((_ = p), (p = n)), + p !== n + ? (e.length > _ + ? ((d = e.charAt(_)), _++) + : ((d = n), 0 === re && ce(c)), + d !== n ? (s = p = [p, d]) : ((_ = s), (s = n))) + : ((_ = s), (s = n)); + else i = n; + i !== n ? (A = o = [o, i]) : ((_ = A), (A = n)); + } else (_ = A), (A = n); + if ((A === n && (A = null), A !== n)) { + if (((o = []), (i = ve()) !== n)) + for (; i !== n; ) o.push(i), (i = ve()); + else o = n; + o !== n ? ((Z = t), (t = r = {})) : ((_ = t), (t = n)); + } else (_ = t), (t = n); + } else (_ = t), (t = n); + if ( + t === n && + ((t = _), + (r = Ce()) !== n && + (A = (function () { + var e; + (e = we()) === n && (e = Be()); + return e; + })()) !== n + ? ((o = be()) === n && (o = null), + o !== n + ? (58 === e.charCodeAt(_) + ? ((i = ':'), _++) + : ((i = n), 0 === re && ce(g)), + i !== n + ? ((s = be()) === n && (s = null), + s !== n && (p = de()) !== n + ? ((Z = t), (t = r = l(A, p))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)), + t === n && + ((t = _), + (r = Ce()) !== n && (A = Ee()) !== n + ? ((o = be()) === n && (o = null), + o !== n + ? (58 === e.charCodeAt(_) + ? ((i = ':'), _++) + : ((i = n), 0 === re && ce(g)), + i !== n + ? ((s = be()) === n && (s = null), + s !== n && (p = de()) !== n + ? ((Z = t), (t = r = l(A, p))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)), + t === n)) + ) { + if (((t = _), (r = Ce()) !== n)) + if ((A = Ee()) !== n) + if ((o = be()) !== n) + if ( + (i = (function () { + var e; + (e = me()) === n && (e = we()) === n && (e = ye()); + return e; + })()) !== n + ) { + if (((s = []), (p = ve()) !== n)) + for (; p !== n; ) s.push(p), (p = ve()); + else s = n; + s !== n + ? ((Z = t), (t = r = l(A, i))) + : ((_ = t), (t = n)); + } else (_ = t), (t = n); + else (_ = t), (t = n); + else (_ = t), (t = n); + else (_ = t), (t = n); + if (t === n) + if (((t = _), (r = Ce()) !== n)) + if ((A = Ee()) !== n) { + if ( + ((o = []), + (i = _), + (s = be()) === n && (s = null), + s !== n + ? (44 === e.charCodeAt(_) + ? ((p = ','), _++) + : ((p = n), 0 === re && ce(u)), + p !== n + ? ((d = be()) === n && (d = null), + d !== n && (C = Ee()) !== n + ? ((Z = i), (i = s = h(0, C))) + : ((_ = i), (i = n))) + : ((_ = i), (i = n))) + : ((_ = i), (i = n)), + i !== n) + ) + for (; i !== n; ) + o.push(i), + (i = _), + (s = be()) === n && (s = null), + s !== n + ? (44 === e.charCodeAt(_) + ? ((p = ','), _++) + : ((p = n), 0 === re && ce(u)), + p !== n + ? ((d = be()) === n && (d = null), + d !== n && (C = Ee()) !== n + ? ((Z = i), (i = s = h(0, C))) + : ((_ = i), (i = n))) + : ((_ = i), (i = n))) + : ((_ = i), (i = n)); + else o = n; + o !== n + ? ((i = be()) === n && (i = null), + i !== n + ? (58 === e.charCodeAt(_) + ? ((s = ':'), _++) + : ((s = n), 0 === re && ce(g)), + s !== n + ? ((p = be()) === n && (p = null), + p !== n && (d = de()) !== n + ? ((Z = t), + (f = A), + (I = o), + (E = d), + (t = r = Object.assign( + {}, + ...[f] + .concat(I) + .map((e) => ({ [e]: E })) + ))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)); + } else (_ = t), (t = n); + else (_ = t), (t = n); + } + return t; + } + function de() { + var t, r, A, o, i, a, c; + if ( + ((t = _), + (r = _), + re++, + (A = _), + (o = Se()) !== n && + (i = (function () { + var t, r, A; + (t = _), + (r = []), + 32 === e.charCodeAt(_) + ? ((A = ' '), _++) + : ((A = n), 0 === re && ce(d)); + for (; A !== n; ) + r.push(A), + 32 === e.charCodeAt(_) + ? ((A = ' '), _++) + : ((A = n), 0 === re && ce(d)); + r !== n + ? ((Z = _), + (A = (A = r.length === (Ne + 1) * ke) ? void 0 : n) !== + n + ? (t = r = [r, A]) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)); + return t; + })()) !== n + ? (45 === e.charCodeAt(_) + ? ((a = '-'), _++) + : ((a = n), 0 === re && ce(s)), + a !== n && (c = be()) !== n + ? (A = o = [o, i, a, c]) + : ((_ = A), (A = n))) + : ((_ = A), (A = n)), + re--, + A !== n ? ((_ = r), (r = void 0)) : (r = n), + r !== n && + (A = ve()) !== n && + (o = fe()) !== n && + (i = (function () { + var e, t, r, A; + for (e = _, t = [], r = ue(); r !== n; ) + t.push(r), (r = ue()); + return ( + t !== n && ((Z = e), (A = t), (t = [].concat(...A))), + (e = t) + ); + })()) !== n && + (a = Ie()) !== n + ? ((Z = t), (t = r = i)) + : ((_ = t), (t = n)), + t === n && + ((t = _), + (r = Se()) !== n && + (A = fe()) !== n && + (o = he()) !== n && + (i = Ie()) !== n + ? ((Z = t), (t = r = o)) + : ((_ = t), (t = n)), + t === n)) + ) + if ( + ((t = _), + (r = (function () { + var t; + (t = me()) === n && + (t = (function () { + var t, r; + (t = _), + 'true' === e.substr(_, 4) + ? ((r = 'true'), (_ += 4)) + : ((r = n), 0 === re && ce(S)); + r !== n && ((Z = t), (r = !0)); + (t = r) === n && + ((t = _), + 'false' === e.substr(_, 5) + ? ((r = 'false'), (_ += 5)) + : ((r = n), 0 === re && ce(k)), + r !== n && ((Z = t), (r = !1)), + (t = r)); + return t; + })()) === n && + (t = we()) === n && + (t = Be()); + return t; + })()) !== n) + ) { + if (((A = []), (o = ve()) !== n)) + for (; o !== n; ) A.push(o), (o = ve()); + else A = n; + A !== n ? ((Z = t), (t = r = r)) : ((_ = t), (t = n)); + } else (_ = t), (t = n); + return t; + } + function Ce() { + var t, r, A; + for ( + re++, + t = _, + r = [], + 32 === e.charCodeAt(_) + ? ((A = ' '), _++) + : ((A = n), 0 === re && ce(d)); + A !== n; + + ) + r.push(A), + 32 === e.charCodeAt(_) + ? ((A = ' '), _++) + : ((A = n), 0 === re && ce(d)); + return ( + r !== n + ? ((Z = _), + (A = (A = r.length === Ne * ke) ? void 0 : n) !== n + ? (t = r = [r, A]) + : ((_ = t), (t = n))) + : ((_ = t), (t = n)), + re--, + t === n && ((r = n), 0 === re && ce(p)), + t + ); + } + function fe() { + return (Z = _), Ne++, !0 ? void 0 : n; + } + function Ie() { + return (Z = _), Ne--, !0 ? void 0 : n; + } + function Ee() { + var e, t, r; + if ((e = we()) === n) { + if (((e = _), (t = []), (r = ye()) !== n)) + for (; r !== n; ) t.push(r), (r = ye()); + else t = n; + t !== n && ((Z = e), (t = Ae())), (e = t); + } + return e; + } + function Be() { + var t, r, A, o, i, s; + if ( + (re++, + (t = _), + f.test(e.charAt(_)) + ? ((r = e.charAt(_)), _++) + : ((r = n), 0 === re && ce(I)), + r !== n) + ) { + for ( + A = [], + o = _, + (i = be()) === n && (i = null), + i !== n + ? (E.test(e.charAt(_)) + ? ((s = e.charAt(_)), _++) + : ((s = n), 0 === re && ce(B)), + s !== n ? (o = i = [i, s]) : ((_ = o), (o = n))) + : ((_ = o), (o = n)); + o !== n; + + ) + A.push(o), + (o = _), + (i = be()) === n && (i = null), + i !== n + ? (E.test(e.charAt(_)) + ? ((s = e.charAt(_)), _++) + : ((s = n), 0 === re && ce(B)), + s !== n ? (o = i = [i, s]) : ((_ = o), (o = n))) + : ((_ = o), (o = n)); + A !== n ? ((Z = t), (t = r = y())) : ((_ = t), (t = n)); + } else (_ = t), (t = n); + return re--, t === n && ((r = n), 0 === re && ce(C)), t; + } + function ye() { + var t, r, A, o, i; + if ( + ((t = _), + '--' === e.substr(_, 2) + ? ((r = '--'), (_ += 2)) + : ((r = n), 0 === re && ce(m)), + r === n && (r = null), + r !== n) + ) + if ( + (w.test(e.charAt(_)) + ? ((A = e.charAt(_)), _++) + : ((A = n), 0 === re && ce(Q)), + A !== n) + ) { + for ( + o = [], + D.test(e.charAt(_)) + ? ((i = e.charAt(_)), _++) + : ((i = n), 0 === re && ce(b)); + i !== n; + + ) + o.push(i), + D.test(e.charAt(_)) + ? ((i = e.charAt(_)), _++) + : ((i = n), 0 === re && ce(b)); + o !== n ? ((Z = t), (t = r = y())) : ((_ = t), (t = n)); + } else (_ = t), (t = n); + else (_ = t), (t = n); + return t; + } + function me() { + var t, r; + return ( + (t = _), + 'null' === e.substr(_, 4) + ? ((r = 'null'), (_ += 4)) + : ((r = n), 0 === re && ce(v)), + r !== n && ((Z = t), (r = null)), + (t = r) + ); + } + function we() { + var t, r, A, o; + return ( + re++, + (t = _), + 34 === e.charCodeAt(_) + ? ((r = '"'), _++) + : ((r = n), 0 === re && ce(F)), + r !== n + ? (34 === e.charCodeAt(_) + ? ((A = '"'), _++) + : ((A = n), 0 === re && ce(F)), + A !== n ? ((Z = t), (t = r = '')) : ((_ = t), (t = n))) + : ((_ = t), (t = n)), + t === n && + ((t = _), + 34 === e.charCodeAt(_) + ? ((r = '"'), _++) + : ((r = n), 0 === re && ce(F)), + r !== n && + (A = (function () { + var e, t, r; + if (((e = _), (t = []), (r = Qe()) !== n)) + for (; r !== n; ) t.push(r), (r = Qe()); + else t = n; + t !== n && ((Z = e), (t = t.join(''))); + return (e = t); + })()) !== n + ? (34 === e.charCodeAt(_) + ? ((o = '"'), _++) + : ((o = n), 0 === re && ce(F)), + o !== n ? ((Z = t), (t = r = A)) : ((_ = t), (t = n))) + : ((_ = t), (t = n))), + re--, + t === n && ((r = n), 0 === re && ce(N)), + t + ); + } + function Qe() { + var t, r, A, o, i, s, a, c, g, l; + return ( + K.test(e.charAt(_)) + ? ((t = e.charAt(_)), _++) + : ((t = n), 0 === re && ce(M)), + t === n && + ((t = _), + '\\"' === e.substr(_, 2) + ? ((r = '\\"'), (_ += 2)) + : ((r = n), 0 === re && ce(R)), + r !== n && ((Z = t), (r = '"')), + (t = r) === n && + ((t = _), + '\\\\' === e.substr(_, 2) + ? ((r = '\\\\'), (_ += 2)) + : ((r = n), 0 === re && ce(x)), + r !== n && ((Z = t), (r = '\\')), + (t = r) === n && + ((t = _), + '\\/' === e.substr(_, 2) + ? ((r = '\\/'), (_ += 2)) + : ((r = n), 0 === re && ce(L)), + r !== n && ((Z = t), (r = '/')), + (t = r) === n && + ((t = _), + '\\b' === e.substr(_, 2) + ? ((r = '\\b'), (_ += 2)) + : ((r = n), 0 === re && ce(P)), + r !== n && ((Z = t), (r = '\b')), + (t = r) === n && + ((t = _), + '\\f' === e.substr(_, 2) + ? ((r = '\\f'), (_ += 2)) + : ((r = n), 0 === re && ce(O)), + r !== n && ((Z = t), (r = '\f')), + (t = r) === n && + ((t = _), + '\\n' === e.substr(_, 2) + ? ((r = '\\n'), (_ += 2)) + : ((r = n), 0 === re && ce(U)), + r !== n && ((Z = t), (r = '\n')), + (t = r) === n && + ((t = _), + '\\r' === e.substr(_, 2) + ? ((r = '\\r'), (_ += 2)) + : ((r = n), 0 === re && ce(T)), + r !== n && ((Z = t), (r = '\r')), + (t = r) === n && + ((t = _), + '\\t' === e.substr(_, 2) + ? ((r = '\\t'), (_ += 2)) + : ((r = n), 0 === re && ce(j)), + r !== n && ((Z = t), (r = '\t')), + (t = r) === n && + ((t = _), + '\\u' === e.substr(_, 2) + ? ((r = '\\u'), (_ += 2)) + : ((r = n), 0 === re && ce(Y)), + r !== n && + (A = De()) !== n && + (o = De()) !== n && + (i = De()) !== n && + (s = De()) !== n + ? ((Z = t), + (a = A), + (c = o), + (g = i), + (l = s), + (t = r = String.fromCharCode( + parseInt(`0x${a}${c}${g}${l}`) + ))) + : ((_ = t), (t = n))))))))))), + t + ); + } + function De() { + var t; + return ( + G.test(e.charAt(_)) + ? ((t = e.charAt(_)), _++) + : ((t = n), 0 === re && ce(H)), + t + ); + } + function be() { + var t, r; + if ( + (re++, + (t = []), + q.test(e.charAt(_)) + ? ((r = e.charAt(_)), _++) + : ((r = n), 0 === re && ce(z)), + r !== n) + ) + for (; r !== n; ) + t.push(r), + q.test(e.charAt(_)) + ? ((r = e.charAt(_)), _++) + : ((r = n), 0 === re && ce(z)); + else t = n; + return re--, t === n && ((r = n), 0 === re && ce(J)), t; + } + function ve() { + var e, t, r, A, o, i; + if (((e = _), (t = Se()) !== n)) { + for ( + r = [], + A = _, + (o = be()) === n && (o = null), + o !== n && (i = Se()) !== n + ? (A = o = [o, i]) + : ((_ = A), (A = n)); + A !== n; + + ) + r.push(A), + (A = _), + (o = be()) === n && (o = null), + o !== n && (i = Se()) !== n + ? (A = o = [o, i]) + : ((_ = A), (A = n)); + r !== n ? (e = t = [t, r]) : ((_ = e), (e = n)); + } else (_ = e), (e = n); + return e; + } + function Se() { + var t; + return ( + '\r\n' === e.substr(_, 2) + ? ((t = '\r\n'), (_ += 2)) + : ((t = n), 0 === re && ce(W)), + t === n && + (10 === e.charCodeAt(_) + ? ((t = '\n'), _++) + : ((t = n), 0 === re && ce(V)), + t === n && + (13 === e.charCodeAt(_) + ? ((t = '\r'), _++) + : ((t = n), 0 === re && ce(X)))), + t + ); + } + const ke = 2; + let Ne = 0; + if ((A = i()) !== n && _ === e.length) return A; + throw ( + (A !== n && _ < e.length && ce({ type: 'end' }), + ge( + te, + ee < e.length ? e.charAt(ee) : null, + ee < e.length ? ae(ee, ee + 1) : ae(ee, ee) + )) + ); + }, + }); + }, + 20103: (e, t, r) => { + let A; + e.exports = () => ( + void 0 === A && + (A = r(78761) + .brotliDecompressSync( + Buffer.from( + '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', + 'base64' + ) + ) + .toString()), + A + ); + }, + 42357: (e) => { + 'use strict'; + e.exports = require('assert'); + }, + 64293: (e) => { + 'use strict'; + e.exports = require('buffer'); + }, + 63129: (e) => { + 'use strict'; + e.exports = require('child_process'); + }, + 27619: (e) => { + 'use strict'; + e.exports = require('constants'); + }, + 76417: (e) => { + 'use strict'; + e.exports = require('crypto'); + }, + 40881: (e) => { + 'use strict'; + e.exports = require('dns'); + }, + 28614: (e) => { + 'use strict'; + e.exports = require('events'); + }, + 35747: (e) => { + 'use strict'; + e.exports = require('fs'); + }, + 98605: (e) => { + 'use strict'; + e.exports = require('http'); + }, + 97565: (e) => { + 'use strict'; + e.exports = require('http2'); + }, + 57211: (e) => { + 'use strict'; + e.exports = require('https'); + }, + 32282: (e) => { + 'use strict'; + e.exports = require('module'); + }, + 11631: (e) => { + 'use strict'; + e.exports = require('net'); + }, + 12087: (e) => { + 'use strict'; + e.exports = require('os'); + }, + 85622: (e) => { + 'use strict'; + e.exports = require('path'); + }, + 71191: (e) => { + 'use strict'; + e.exports = require('querystring'); + }, + 51058: (e) => { + 'use strict'; + e.exports = require('readline'); + }, + 92413: (e) => { + 'use strict'; + e.exports = require('stream'); + }, + 24304: (e) => { + 'use strict'; + e.exports = require('string_decoder'); + }, + 4016: (e) => { + 'use strict'; + e.exports = require('tls'); + }, + 33867: (e) => { + 'use strict'; + e.exports = require('tty'); + }, + 78835: (e) => { + 'use strict'; + e.exports = require('url'); + }, + 31669: (e) => { + 'use strict'; + e.exports = require('util'); + }, + 78761: (e) => { + 'use strict'; + e.exports = require('zlib'); + }, + }, + t = {}; + function r(A) { + if (t[A]) return t[A].exports; + var n = (t[A] = { id: A, loaded: !1, exports: {} }); + return e[A].call(n.exports, n, n.exports, r), (n.loaded = !0), n.exports; + } + return ( + (r.c = t), + (r.n = (e) => { + var t = e && e.__esModule ? () => e.default : () => e; + return r.d(t, { a: t }), t; + }), + (r.t = function (e, t) { + if ((1 & t && (e = this(e)), 8 & t)) return e; + if (4 & t && 'object' == typeof e && e && e.__esModule) return e; + var A = Object.create(null); + r.r(A); + var n = {}; + if (2 & t && 'object' == typeof e && e) + for (const t in e) n[t] = () => e[t]; + return (n.default = () => e), r.d(A, n), A; + }), + (r.d = (e, t) => { + for (var A in t) + r.o(t, A) && + !r.o(e, A) && + Object.defineProperty(e, A, { enumerable: !0, get: t[A] }); + }), + (r.hmd = (e) => ( + (e = Object.create(e)).children || (e.children = []), + Object.defineProperty(e, 'exports', { + enumerable: !0, + set: () => { + throw new Error( + 'ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + + e.id + ); + }, + }), + e + )), + (r.o = (e, t) => Object.prototype.hasOwnProperty.call(e, t)), + (r.r = (e) => { + 'undefined' != typeof Symbol && + Symbol.toStringTag && + Object.defineProperty(e, Symbol.toStringTag, { value: 'Module' }), + Object.defineProperty(e, '__esModule', { value: !0 }); + }), + (r.nmd = (e) => ((e.paths = []), e.children || (e.children = []), e)), + r(43418) + ); +})(); diff --git a/.yarnrc.yml b/.yarnrc.yml new file mode 100644 index 000000000..c4830621a --- /dev/null +++ b/.yarnrc.yml @@ -0,0 +1,3 @@ +yarnPath: '.yarn/releases/yarn-berry.cjs' + +nodeLinker: node-modules diff --git a/config.js b/config.js deleted file mode 100644 index 22e511667..000000000 --- a/config.js +++ /dev/null @@ -1,19 +0,0 @@ -module.exports = { - url: { - production: { - LANDING: 'https://craft.js.org/', - DOCUMENTATION: 'https://craft.js.org/r/docs/overview/', - BASIC_EXAMPLE: 'https://craft.js.org/examples/basic/', - }, - staging: { - LANDING: 'https://craftjs.netlify.com/', - DOCUMENTATION: 'https://craftjs.netlify.com/r/docs/overview/', - BASIC_EXAMPLE: 'https://craftjs.netlify.com/examples/basic/', - }, - development: { - LANDING: 'http://localhost:3001/', - DOCUMENTATION: 'http://localhost:3000/r/docs/overview/', - BASIC_EXAMPLE: 'http://localhost:3002/', - }, - }[process.env.ENV || 'development'], -}; diff --git a/cypress.json b/cypress.json new file mode 100644 index 000000000..fa61e4d87 --- /dev/null +++ b/cypress.json @@ -0,0 +1,3 @@ +{ + "baseUrl": "http://localhost:3002" +} diff --git a/cypress/integration/frame.ts b/cypress/integration/frame.ts new file mode 100644 index 000000000..9fe8149c4 --- /dev/null +++ b/cypress/integration/frame.ts @@ -0,0 +1,146 @@ +describe('Frame', () => { + beforeEach(() => { + cy.visit('/'); + }); + + it('should be possible to move the elements around in the frame', () => { + // at the start the root should have 4 elements + cy.getByTestId('root-container') + .as('root-container') + .children() + .should('have.length', 4); + + // we want to drop the "Click me" Button inside the CardBottom + // before that the CardBottom should only have one button + cy.getByTestId('card-bottom') + .as('card-bottom') + .children() + .should('have.length', 1); + // we verify that the button is draggable and drop it inside the CardBottom + cy.getByTestId('frame-button') + .should('have.attr', 'draggable', 'true') + .dragAndDrop('@card-bottom', { + position: 'inside', + }); + // CardBottom now should have 2 elements + cy.get('@card-bottom').children().should('have.length', 2); + + // we want to drop the "Hi world!" Text as second element in the CardTop + // before that we verify that CardTop has two children + cy.getByTestId('card-top') + .as('card-top') + .children() + .should('have.length', 2); + + cy.getByTestId('card-top-text-1').as('card-top-text-1'); + cy.getByTestId('frame-text') + .should('have.attr', 'draggable', 'true') + .dragAndDrop('@card-top-text-1', { + position: 'below', + }); + cy.get('@card-top').children().should('have.length', 3); + + // the root should now only have 2 children (the Card and the Container) + cy.get('@root-container').children().should('have.length', 2); + + // we now want to drop the Card inside the Container + cy.getByTestId('frame-container') + .as('frame-container') + .children() + .should('have.length', 1); + cy.getByTestId('frame-card').dragAndDrop('@frame-container', { + position: 'inside', + }); + cy.get('@frame-container').children().should('have.length', 2); + cy.get('@root-container').children().should('have.length', 1); + }); + + it('should not be possible to drag anything inside the frame when the editor is disabled', () => { + // we disable the editor + cy.contains('Enable').click(); + + // no element should be draggable + cy.getByTestId('frame-card').should('have.attr', 'draggable', 'false'); + cy.getByTestId('card-top-text-1').should('have.attr', 'draggable', 'false'); + cy.getByTestId('card-top-text-2').should('have.attr', 'draggable', 'false'); + cy.getByTestId('card-bottom-button').should( + 'have.attr', + 'draggable', + 'false' + ); + cy.getByTestId('frame-button').should('have.attr', 'draggable', 'false'); + cy.getByTestId('frame-text').should('have.attr', 'draggable', 'false'); + cy.getByTestId('frame-container').should('have.attr', 'draggable', 'false'); + cy.getByTestId('frame-container-text').should( + 'have.attr', + 'draggable', + 'false' + ); + }); + + it('should be possible to delete every element', () => { + // to keep it DRY we use this simple helper + const deleteByTestId = (testId: string) => { + cy.getByTestId(testId).click(); + cy.contains('Delete').click(); + }; + + // these calls all follow the same schema: + // 1. verify that the container has a certain number of children before we delete + // 2. select the element we want to delete + // 3. delete the element + // 4. verify that the container now has one less element + + cy.getByTestId('root-container') + .as('root-container') + .children() + .should('have.length', 4); + + cy.getByTestId('card-top').children().should('have.length', 2); + deleteByTestId('card-top-text-1'); + deleteByTestId('card-top-text-2'); + cy.getByTestId('card-top').children().should('have.length', 0); + + cy.getByTestId('card-bottom').children().should('have.length', 1); + deleteByTestId('card-bottom-button'); + cy.getByTestId('card-bottom').children().should('have.length', 0); + + deleteByTestId('frame-card'); + cy.get('@root-container').children().should('have.length', 3); + + deleteByTestId('frame-button'); + cy.get('@root-container').children().should('have.length', 2); + + deleteByTestId('frame-text'); + cy.get('@root-container').children().should('have.length', 1); + + cy.getByTestId('frame-container').children().should('have.length', 1); + deleteByTestId('frame-container-text'); + cy.getByTestId('frame-container').children().should('have.length', 0); + + deleteByTestId('frame-container'); + cy.get('@root-container').children().should('have.length', 0); + }); + + it('should not be possible to delete an element when the editor is disabled', () => { + // first we disable the editor + cy.contains('Enable').click(); + + // then we check that the SettingsPanel does not open for any of the elements + [ + 'card-top-text-1', + 'card-top-text-2', + 'card-bottom-button', + 'card-top', + 'card-bottom', + 'frame-card', + 'frame-button', + 'frame-text', + 'frame-container-text', + 'frame-container', + ].forEach((testId) => { + cy.getByTestId(testId).click(); + cy.contains('Delete').should('not.exist'); + }); + }); +}); diff --git a/cypress/integration/history.ts b/cypress/integration/history.ts new file mode 100644 index 000000000..c5fb5b0e5 --- /dev/null +++ b/cypress/integration/history.ts @@ -0,0 +1,206 @@ +describe('Test History', () => { + beforeEach(() => { + cy.visit('/'); + + cy.contains('Undo').as('undo-button'); + cy.contains('Redo').as('redo-button'); + + // before any changes have been made, both undo and redo should be disabled + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('be.disabled'); + + // since we need the root-container in (almost) every test we load it here + cy.getByTestId('root-container') + .as('root') + .children() + .should('have.length', 4); + }); + + it('should be possible to undo and redo changes to props', () => { + // first we want to test if we can undo changes made to props + const originalText = 'Hi world!'; + cy.getByTestId('frame-text') + .as('frame-text') + .should('have.text', originalText); + + const newText = 'Hello world!'; + // The Text component uses a ContentEditable inside, so we need to click the

to be able to enter text + cy.get('@frame-text').find('p').click().type(`{selectAll}${newText}`); + cy.get('@frame-text').should('have.text', newText); + + cy.get('@redo-button').should('be.disabled'); + cy.get('@undo-button').should('not.be.disabled').click(); + + cy.get('@frame-text').should('have.text', originalText); + + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('not.be.disabled').click(); + cy.get('@frame-text').should('have.text', newText); + }); + + it('should be possible to undo and redo changes made via drag and drop', () => { + cy.getByTestId('root-container') + .as('root') + .children() + .should('have.length', 4); + + // The first plan is to drag every component into the frame-container component + cy.getByTestId('frame-container') + .as('container') + .children() + .should('have.length', 1); + + // TODO currently I do not know why but without the wait. test gets flaky + // and fails randomly because cypress is not able to drag the card into the container + cy.wait(100); + cy.getByTestId('frame-card') + .as('card') + .dragAndDrop('@container', { position: 'inside' }); + cy.getByTestId('frame-button') + .as('button') + .dragAndDrop('@container', { position: 'inside' }); + + cy.getByTestId('frame-text') + .as('text') + .dragAndDrop('@container', { position: 'inside' }); + + // afterwards all the elements should be inside the Container + cy.get('@root').children().should('have.length', 1); + cy.get('@container').children().should('have.length', 4); + + cy.get('@redo-button').should('be.disabled'); + cy.get('@undo-button').should('not.be.disabled').click(); + + // we now want to undo all the changes and check along the way, that undoing works as expected + cy.get('@redo-button').should('not.be.disabled'); + + cy.get('@root').children().should('have.length', 2); + cy.get('@container').children().should('have.length', 3); + + cy.get('@undo-button').click(); + cy.get('@root').children().should('have.length', 3); + cy.get('@container').children().should('have.length', 2); + + cy.get('@undo-button').click(); + cy.get('@root').children().should('have.length', 4); + cy.get('@container').children().should('have.length', 1); + + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('not.be.disabled'); + + // now we want to redo 2 out of 3 times ... + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + cy.get('@redo-button').should('not.be.disabled'); + + cy.getByTestId('card-top-text-1').as('card-top-text-1'); + cy.get('@text').dragAndDrop('@card-top-text-1', { + position: 'below', + }); + + // ... so we can verify that the remaining redo gets overwritten correctly + cy.get('@redo-button').should('be.disabled'); + + // now we undo 3 times to get back to the initial state + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + + cy.get('@root').children().should('have.length', 4); + }); + + it('should be possible to undo and redo deleted elements', () => { + // in this test we remove every element + ['frame-card', 'frame-button', 'frame-text', 'frame-container'].forEach( + (testId) => { + // we click on the left side to not accidentally select a component inside Card or Container + cy.getByTestId(testId).click('left'); + cy.contains('Delete').click(); + } + ); + + cy.get('@undo-button').should('not.be.disabled'); + cy.get('@root').children().should('have.length', 0); + + // we undo the deletions + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + + cy.get('@root').children().should('have.length', 4); + + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('not.be.disabled'); + + // and redo the deletions + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + + cy.get('@root').children().should('have.length', 0); + }); + + it('should be possible to drag elements from the toolbox and undo those changes', () => { + // we drag every component from the toolbox onto the root + [ + 'toolbox-button', + 'toolbox-text', + 'toolbox-container', + 'toolbox-card', + ].forEach((testId) => { + cy.getByTestId(testId).dragAndDrop('@root', { + position: 'inside', + }); + }); + + // the root now should have 4 more elements + cy.get('@root').children().should('have.length', 8); + + // and the undo button should not be disabled + cy.get('@undo-button').should('not.be.disabled'); + cy.get('@redo-button').should('be.disabled'); + + // clicking the undo button 4 times should reset the changes + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + cy.get('@undo-button').click(); + + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('not.be.disabled'); + + cy.get('@root').children().should('have.length', 4); + + // clicking the redo button 4 times should result in 8 elements under root again + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + cy.get('@redo-button').click(); + + cy.get('@root').children().should('have.length', 8); + }); + + it('should not be possible to undo/redo changes when the editor is disabled', () => { + // we delete both the button an the text from the frame + cy.getByTestId('frame-button').click(); + cy.contains('Delete').click(); + + cy.getByTestId('frame-text').click(); + cy.contains('Delete').click(); + + // we undo the deletion of the Text element to have a redo action available + cy.get('@undo-button').click(); + + cy.get('@undo-button').should('not.be.disabled'); + cy.get('@redo-button').should('not.be.disabled'); + + // we disable the editor + cy.contains('Enable').click(); + + // undo / redo should now be impossible + cy.get('@undo-button').should('be.disabled'); + cy.get('@redo-button').should('be.disabled'); + }); +}); diff --git a/cypress/integration/props.ts b/cypress/integration/props.ts new file mode 100644 index 000000000..10925cd02 --- /dev/null +++ b/cypress/integration/props.ts @@ -0,0 +1,169 @@ +// In this test we use the settings panel to change the props of the components +// we verify that the selection worked by checking the classNames +// In a real world application this could potentially be brittle. We do not want to test implementation details. +// It would be better to use a visual testing instead of checking for the existence of the classNames +// see more: https://docs.cypress.io/guides/tooling/visual-testing.html +describe('Props / SettingsPanel', () => { + beforeEach(() => { + cy.visit('/'); + }); + + it('should be possible to change the props of a Text element', () => { + // first we select a text component + cy.getByTestId('card-top-text-1') + .as('text') + // The text component renders a ContentEditable which receives the font-size + .find('p') + .should('have.css', 'font-size', '20px') + .click(); + + // the settings panel should be visible and render an editor for one prop + cy.getByTestId('settings-panel') + .should('exist') + .find('fieldset') + .should('have.length', 1); + + // it should say, that we selected the Text component + cy.getByTestId('chip-selected').contains('Text'); + + // to keep it simple we select the max value in the slider + cy.get('.MuiSlider-root').click('right'); + cy.get('@text').find('p').should('have.css', 'font-size', '50px'); + + // and afterwards the min value + cy.get('.MuiSlider-root').click('left'); + cy.get('@text').find('p').should('have.css', 'font-size', '1px'); + }); + + it('should be possible to change the props for the button', () => { + // the other tests follow the same schema as above: + // 1. select the component + // 2. verify that the settings panel is visible and shows the correct information + // 3. change the props by using the SettingsPanel + // 4. verify the changes + + cy.getByTestId('frame-button').as('button').click(); + cy.get('@button') + .should('have.class', 'MuiButton-sizeSmall') + .should('have.class', 'MuiButton-contained') + .should('have.class', 'MuiButton-containedPrimary'); + + cy.getByTestId('settings-panel') + .should('exist') + .find('fieldset') + // this time we should have three props we can edit + .should('have.length', 3); + + cy.getByTestId('chip-selected').contains('Button'); + + cy.contains('Medium').click(); + cy.contains('Outlined').click(); + cy.contains('Secondary').click(); + + cy.get('@button') + // size medium is the default the button does not receive a class for that + .should('have.class', 'MuiButton-outlined') + .should('have.class', 'MuiButton-outlinedSecondary'); + + cy.contains('Large').click(); + cy.get('[role="radiogroup"]').within(() => { + cy.contains('Text').click(); + }); + cy.contains('Default').click(); + + cy.get('@button') + .should('have.class', 'MuiButton-sizeLarge') + .should('have.class', 'MuiButton-text') + .should('have.class', 'MuiButton-textSizeLarge'); + }); + + it('should be possible to change the props for the container', () => { + // The Card component renders a Container so we test both the Card and the Container by itself + [ + { + componentName: 'Card', + testId: 'frame-card', + initialBackgroundColor: 'rgb(255, 255, 255)', + initialPadding: '3px', + }, + { + componentName: 'Container', + testId: 'frame-container', + initialBackgroundColor: 'rgb(153, 153, 153)', + initialPadding: '6px', + }, + ].forEach( + ({ testId, initialBackgroundColor, initialPadding, componentName }) => { + // we click left to not accidentally click the text inside the container/card + cy.getByTestId(testId).as('container').click('left'); + + cy.get('@container') + .should('have.css', 'background-color', initialBackgroundColor) + .should('have.css', 'padding', initialPadding); + + cy.getByTestId('settings-panel') + .should('exist') + .find('fieldset') + .should('have.length', 2); + + cy.getByTestId('chip-selected').contains(componentName); + + cy.get('[name="background-color"]') + .as('input-background-color') + // we focus the input to be able to close the color picker + .focus() + // instead of using the color picker we directly enter the value inside the input + .type('{selectAll}#FF0000') + // we call blur to close the color picker + .blur(); + cy.get('.MuiSlider-root').as('input-padding').click('right'); + + cy.get('@container') + .should('have.css', 'background-color', 'rgb(255, 0, 0)') + .should('have.css', 'padding', '100px'); + + cy.get('@input-background-color') + .focus() + .type('{selectAll}#FFFF00') + .blur(); + cy.get('@input-padding').click('left'); + + cy.get('@container') + .should('have.css', 'background-color', 'rgb(255, 255, 0)') + .should('have.css', 'padding', '0px'); + } + ); + }); + + it('CardTop and CardBottom should not have settings', () => { + // both CardTop and CardBottom don't have a prop editor + // we select each component + cy.getByTestId('card-top').click('left'); + // the settings panel should exist but should not be visible + cy.getByTestId('settings-panel').should('exist').should('not.be.visible'); + cy.getByTestId('chip-selected').contains('CardTop'); + + cy.getByTestId('card-bottom').click('left'); + cy.getByTestId('settings-panel').should('exist').should('not.be.visible'); + cy.getByTestId('chip-selected').contains('CardBottom'); + }); + + it('should not be possible to edit the props / open the SettingsPanel when the editor is disabled', () => { + cy.contains('Enable').click(); + + // for each element... + [ + 'frame-text', + 'frame-button', + 'frame-container', + 'frame-card', + 'card-top', + 'card-bottom', + ].forEach((testId) => { + // ... we select the element ... + cy.getByTestId(testId).click(); + // ... and expect the settings panel to not be in the DOM + cy.getByTestId('settings-panel').should('not.exist'); + }); + }); +}); diff --git a/cypress/integration/toolbox.ts b/cypress/integration/toolbox.ts new file mode 100644 index 000000000..6dc2bc034 --- /dev/null +++ b/cypress/integration/toolbox.ts @@ -0,0 +1,341 @@ +describe('Toolbox', () => { + beforeEach(() => { + cy.visit('/'); + + cy.getByTestId('card-top').as('card-top'); + cy.getByTestId('card-bottom').as('card-bottom'); + cy.getByTestId('root-container').as('root-container'); + cy.getByTestId('frame-container').as('frame-container'); + }); + + describe('Test Toolbox Button', () => { + beforeEach(() => { + cy.getByTestId('toolbox-button') + .as('toolbox-button') + .should('have.attr', 'draggable', 'true'); + }); + + it('should be possible to drag buttons to the bottom of the card', () => { + cy.getByTestId('card-bottom-button').as('target-button'); + // we verify that there only is one button in the CardBottom component + cy.get('@card-bottom').children().should('have.length', 1); + + // we drag the button from the toolbox over the button inside the CardBottom + cy.get('@toolbox-button').dragOver('@target-button', { + position: 'right', + }); + + // the success DropIndicator should be visible + cy.getDropIndicator('success').should('exist'); + + // we trigger the drop + cy.get('@toolbox-button').drop(); + + // there should be two components now + cy.get('@card-bottom').children().should('have.length', 2); + + // and both should be buttons + cy.get('@target-button').parent().find('button').should('have.length', 2); + + // we now drop a button to the left of the target button + cy.get('@toolbox-button').dragAndDrop('@target-button', { + position: 'left', + }); + + // there should be three components now + cy.get('@target-button').parent().children().should('have.length', 3); + + // and all of them should be buttons + cy.get('@target-button').parent().find('button').should('have.length', 3); + + // the @target-button should be in the middle + cy.get('@card-bottom') + .children() + .then((children) => children[1]) + .contains('Only buttons down here'); + }); + + it('should not be possible to drag buttons to the top of the card', () => { + cy.getByTestId('card-top-text-1').as('target-text'); + + // we verify that CardTop has currently only 2 elements inside + cy.get('@card-top').children().should('have.length', 2); + + // we drag the button to the CardTop + cy.get('@toolbox-button').dragOver('@target-text'); + + // the error indicator should indicate that it is not possible to drop here + cy.getDropIndicator('error').should('exist'); + + // we trigger the drop + cy.get('@toolbox-button').drop(); + + // there still should only be 2 children + cy.get('@card-top').children().should('have.length', 2); + }); + + it('should be possible to drop buttons anywhere else', () => { + cy.getByTestId('frame-button').as('target-button'); + + // there should be only one button in the editor + cy.get('@root-container').contains('Click me').should('have.length', 1); + + // let's first drop next to the "Click me" button + cy.get('@toolbox-button').dragAndDrop('@target-button', { + position: 'right', + }); + + // there should now be two buttons + cy.get('@root-container') + .find('button:contains("Click me")') + .should('have.length', 2); + + // we now drop the button below "Hi world!" + cy.getByTestId('frame-text').as('target-text'); + + cy.get('@toolbox-button').dragAndDrop('@target-text', { + position: 'below', + }); + + // there should now be three buttons + cy.get('@root-container') + .find('button:contains("Click me")') + .should('have.length', 3); + + // lastly we try to drop the button inside the Container + // this time we do not want to drop the button on one element already inside the container + // but directly into the container + // before we drag & drop there should be only one element inside the container + cy.get('@frame-container').children().should('have.length', 1); + + // we drop inside the container + cy.get('@toolbox-button').dragAndDrop('@frame-container', { + position: 'inside', + }); + + // there now should be two elements inside the container + cy.get('@frame-container').children().should('have.length', 2); + }); + }); + + describe('Test Toolbox Text', () => { + beforeEach(() => { + cy.getByTestId('toolbox-text') + .as('toolbox-text') + .should('have.attr', 'draggable', 'true'); + }); + + // this is basically the same test as the button test + it('should be possible to drop texts inside the CardTop component', () => { + cy.getByTestId('card-top-text-2').as('target-text'); + + // before we start we verify that CardTop currently has 2 elements + cy.get('@card-top').children().should('have.length', 2); + + // this time we test if it's possible to drop between elements by dropping above the second element + cy.get('@toolbox-text').dragAndDrop('@target-text', { + position: 'above', + }); + + // we now should have 3 elements + cy.get('@card-top').children().should('have.length', 3); + + // the element in the middle should be the dropped element + cy.get('@card-top') + .children() + .then(($children) => $children[1]) + .contains('Hi world'); + }); + + // this too, is basically the same test as the one we used to test the Toolbox Button + it('should not be possible to drop texts inside the CardBottom component', () => { + // before we start we verify that the CardBottom currently has only one element + cy.get('@card-bottom').children().should('have.length', 1); + + // we drag the Text from the toolbox over the CardBottom component + cy.get('@toolbox-text').dragOver('@card-bottom', { + position: 'inside', + }); + + // the error indicator should be visible (in the button test, we tested for existence which in our case is the same as being visible) + cy.getDropIndicator('error').should('be.visible'); + + // we drop the text (inside the CardBottom)... + cy.get('@toolbox-text').drop(); + + // ... which should not be possible. That's why we verify that the CardBottom still only has one element + cy.get('@card-bottom').children().should('have.length', 1); + }); + + const numberOfElements = 25; + // because we do not want to copy the whole button test, we try to test something different + // TODO cypress or craft get slower which each Text element dropped. Investigate whether it's cypress, or craft + // currently my money is on cypress + it(`should be possible to drop ${numberOfElements} texts somewhere under root`, () => { + // before we drop $numberOfElements elements we verify that we start with 4 elements + cy.get('@root-container').children().should('have.length', 4); + + for (let count = 0; count < numberOfElements; count++) { + cy.get('@toolbox-text').dragAndDrop('@root-container', { + position: 'inside', + }); + // we add the wait (for 1ms) here, otherwise cypress tries to bulk run the drag and drop and seems to freeze + cy.wait(1); + } + + // afterwards there should be $numberOfElements + the starting 4 elements under root + cy.get('@root-container') + .children() + .should('have.length', numberOfElements + 4); + }); + }); + + describe('Test Toolbox Container', () => { + beforeEach(() => { + cy.getByTestId('toolbox-container') + .as('toolbox-container') + .should('have.attr', 'draggable', 'true'); + }); + + it('should neither be possible to drop Container inside CardTop nor CardBottom', () => { + [ + { + cardPosition: 'top', + expectedChildren: 2, + }, + { + cardPosition: 'bottom', + expectedChildren: 1, + }, + ].forEach(({ cardPosition, expectedChildren }) => { + // like in the other tests we first verify the number of children + cy.get(`@card-${cardPosition}`) + .children() + .should('have.length', expectedChildren); + // then drag the container over the CardTop or CardBottom component + cy.get('@toolbox-container').dragOver(`@card-${cardPosition}`, { + position: 'inside', + }); + // we expect the error drop indicator to exist + cy.getDropIndicator('error').should('exist'); + cy.get('@toolbox-container').drop(); + // after dropping we expect the number of children to be the same as before + cy.get(`@card-${cardPosition}`) + .children() + .should('have.length', expectedChildren); + }); + }); + + // in this test we want to test if ware able to nest containers (drop Containers inside Containers) + it('should be possible to nest Containers', () => { + // again: before we start we verify the number of elements under root + cy.get('@root-container').children().should('have.length', 4); + + // the first container will be dropped under root + cy.get('@toolbox-container').dragAndDrop('@root-container', { + position: 'inside', + }); + + // the first container we dropped, is the first container under root + cy.get('@root-container') + .children() + .then(($children) => $children[0]) + .as('first-container'); + + // we drop the second container inside the first container + cy.get('@toolbox-container').dragAndDrop('@first-container', { + position: 'inside', + }); + + cy.get('@first-container') + .children() + .then(($children) => $children[0]) + .as('second-container'); + + // and the third container is dropped inside the second container + cy.get('@toolbox-container').dragAndDrop('@second-container', { + position: 'inside', + }); + + // we now verify that we dropped correctly + cy.get('@root-container').children().should('have.length', 5); + cy.get('@first-container').children().should('have.length', 1); + cy.get('@second-container').children().should('have.length', 1); + }); + }); + + describe('Test Toolbox Card', () => { + beforeEach(() => { + cy.getByTestId('toolbox-card') + .as('toolbox-card') + .should('have.attr', 'draggable', 'true'); + }); + + it('should not be possible to drop the Card in CardTop or CardBottom', () => { + [ + { + cardPosition: 'top', + expectedChildren: 2, + }, + { + cardPosition: 'bottom', + expectedChildren: 1, + }, + ].forEach(({ cardPosition, expectedChildren }) => { + // like in the other tests we first verify the number of children + cy.get(`@card-${cardPosition}`) + .children() + .should('have.length', expectedChildren); + // then drag the Card over the CardTop or CardBottom component + cy.get('@toolbox-card').dragOver(`@card-${cardPosition}`, { + position: 'inside', + }); + // we expect the error drop indicator to exist + cy.getDropIndicator('error').should('exist'); + cy.get('@toolbox-card').drop(); + // after dropping we expect the number of children to be the same as before + cy.get(`@card-${cardPosition}`) + .children() + .should('have.length', expectedChildren); + }); + }); + + it('should be possible to drop the Card in root as the last element', () => { + cy.get('@root-container').children().should('have.length', 4); + cy.get('@toolbox-card').dragAndDrop('@frame-container', { + position: 'below', + }); + cy.get('@root-container').children().should('have.length', 5); + + cy.get('@root-container') + .children() + .then(($children) => $children[$children.length - 1]) + .within(() => { + cy.contains('Only texts'); + cy.contains('are allowed up here'); + cy.contains('Only buttons down here'); + }); + }); + }); + + describe('Test Toolbox when editor is disabled', () => { + it('should not be possible to drag elements when the editor is disabled', () => { + // first we disable the editor + cy.contains('Enable').click(); + + // since we want to reuse the "toolbox-component" alias we use cy.wrap().each() + cy.wrap(['button', 'text', 'container', 'card']).each((component) => { + cy.get('@root-container').children().should('have.length', 4); + // none of the components should have the 'draggable' attribute + cy.getByTestId(`toolbox-${component}`) + .as(`toolbox-component`) + .should('not.have.attr', 'draggable'); + // it should not be possible to drag the elements. + cy.get('@toolbox-component').dragAndDrop('@root-container', { + position: 'inside', + }); + cy.get('@root-container').children().should('have.length', 4); + }); + }); + }); +}); diff --git a/cypress/plugins/index.js b/cypress/plugins/index.js new file mode 100644 index 000000000..e4818583c --- /dev/null +++ b/cypress/plugins/index.js @@ -0,0 +1,6 @@ +/// + +/** + * @type {Cypress.PluginConfig} + */ +module.exports = () => {}; diff --git a/cypress/support/commands.ts b/cypress/support/commands.ts new file mode 100644 index 000000000..fc1d6fa9d --- /dev/null +++ b/cypress/support/commands.ts @@ -0,0 +1,22 @@ +import './dnd'; + +declare global { + // eslint-disable-next-line @typescript-eslint/no-namespace + namespace Cypress { + interface Chainable { + getByTestId( + selector: string, + ...additionalArguments: any[] + ): Chainable; + } + } +} + +/** + * Will select elements that have a data-cy=$test-id attribute + * Usage: `cy.getByTestId('test-id')` + * @example HTML:

Selector: cy.getByTestId('test-id') + */ +Cypress.Commands.add('getByTestId', (selector, ...args) => { + return cy.get(`[data-cy="${selector}"]`, ...args); +}); diff --git a/cypress/support/dnd.ts b/cypress/support/dnd.ts new file mode 100644 index 000000000..a185a3ffe --- /dev/null +++ b/cypress/support/dnd.ts @@ -0,0 +1,239 @@ +declare global { + // eslint-disable-next-line @typescript-eslint/no-namespace + namespace Cypress { + interface Chainable { + getDropIndicator( + indicator: 'error' | 'success', + indicatorColors?: Record<'error' | 'success', string> + ): Chainable; + + dragAndDrop( + target: string, + options?: Partial + ): Chainable; + + dragOver( + target: string, + options?: Partial + ): Chainable; + + drop(): Chainable; + } + } +} + +export interface DropOptions { + position: 'right' | 'left' | 'right' | 'above' | 'below' | 'inside'; +} + +/** + * Get either the 'success' or 'error' drop indicator + * Use the indicatorColors parameter when you have overwritten the indicator colors + * @example cy.getDropIndicator('success') + */ +Cypress.Commands.add( + 'getDropIndicator', + ( + indicator: 'error' | 'success', + indicatorColors: Record<'error' | 'success', string> = { + error: 'red', + success: 'rgb(98, 196, 98)', + } + ) => { + // in some cases rendering the indicator is slower than cypress, so we have to add a short wait + cy.wait(250); + + return cy.get('div').filter((index, element) => { + return ( + // the next.js render indicator shares some of the styles but additionally has an id + element.id === '' && + element.classList.length === 0 && + element.style.position === 'fixed' && + element.style.zIndex === '99999' && + element.style.backgroundColor === indicatorColors[indicator] + ); + }); + } +); + +class DummyDataTransfer { + data = {}; + + dropEffect = 'move'; + + effectAllowed = 'all'; + files = []; + items = []; + types = []; + + clearData(format) { + if (format) { + delete this.data[format]; + + const index = this.types.indexOf(format); + delete this.types[index]; + delete this.data[index]; + } else { + this.data = {}; + } + } + + setData(format, data) { + this.data[format] = data; + this.items.push(data); + this.types.push(format); + } + + getData(format) { + if (format in this.data) { + return this.data[format]; + } + + return ''; + } + + setDragImage(img, xOffset, yOffset) {} +} + +export const getCoordinatesFromPos = ( + dom: HTMLElement, + position: DropOptions['position'] +) => { + const { left, top, width, height } = dom.getBoundingClientRect(); + + switch (position) { + case 'right': { + return { + x: left + width, + y: top + height / 2, + }; + } + case 'left': { + return { + x: left, + y: top + height / 2, + }; + } + case 'above': { + return { + x: left + width / 2, + y: top, + }; + } + case 'below': { + return { + x: left + width / 2, + y: top + height, + }; + } + case 'inside': { + return { + x: left + 10, + y: top + 10, + }; + } + default: { + return { + x: 0, + y: 0, + }; + } + } +}; + +/** + * Use this command to drag and drop a source component onto/into a target component + * If you want to drop into a component use { position: 'inside' } as options parameter + * + * @example cy.get('source').dragAndDrop('target') + * @example cy.get('source').dragAndDrop('target-container', { position: 'inside' }) + * @example cy.get('source').dragAndDrop('target', { position: 'bottom' }) + */ +Cypress.Commands.add( + 'dragAndDrop', + { + prevSubject: true, + }, + (subject, target, opts: Partial = { position: 'right' }) => { + cy.get(subject).dragOver(target, opts); + cy.get(subject).drop(); + } +); + +/** + * Use this command if you want to drag a source component over a target component. + * You can use the same positions as in the `dragAndDrop` command. + * This command is especially useful when you want to verify that the correct drop indicator is rendered. + * You can use the `drop` command afterwards on the source component to drop the component. + * If you just want to drag and drop a component, use the `dragAndDrop` command instead. + * + * @example ``` + * cy.get('source').dragOver('target'); + * cy.getDropIndicator('success').should('exist'); + * cy.get('source').drop(); + * ``` + */ +Cypress.Commands.add( + 'dragOver', + { + prevSubject: true, + }, + (subject, target, opts: Partial = { position: 'right' }) => { + const { position } = { + ...opts, + }; + + cy.get(target).as('target'); + cy.get('@target').then(($target) => { + const dom = $target[0]; + const { x, y } = getCoordinatesFromPos(dom, position); + + const dataTransfer = new DummyDataTransfer(); + cy.get('@target').parent().as('parent'); + + cy.get(subject) + .trigger('mousedown', { force: true }) + .trigger('dragstart', { + force: true, + dataTransfer, + }); + + if (position === 'inside') { + cy.get('@target').trigger('dragenter', { + clientX: Math.floor(x), + clientY: Math.floor(y), + dataTransfer, + force: true, + }); + } else { + cy.get('@parent').trigger('dragenter', { + clientX: Math.floor(x), + clientY: Math.floor(y), + dataTransfer, + force: true, + }); + } + }); + } +); + +/** + * Use this command to drop a component that has previously been dragged with the command `dragOver` + * + * If you just want to drag and drop a component use the `dragAndDrop` command instead. + * + * @example ``` + * cy.get('source').dragOver('target'); + * cy.get('source').drop(); + * ``` + + */ +Cypress.Commands.add( + 'drop', + { + prevSubject: true, + }, + (subject) => { + cy.get(subject).trigger('dragend', { force: true }); + } +); diff --git a/cypress/support/index.ts b/cypress/support/index.ts new file mode 100644 index 000000000..37a498fb5 --- /dev/null +++ b/cypress/support/index.ts @@ -0,0 +1,20 @@ +// *********************************************************** +// This example support/index.js is processed and +// loaded automatically before your test files. +// +// This is a great place to put global configuration and +// behavior that modifies Cypress. +// +// You can change the location of this file or turn off +// automatically serving support files with the +// 'supportFile' configuration option. +// +// You can read more here: +// https://on.cypress.io/configuration +// *********************************************************** + +// Import commands.js using ES2015 syntax: +import './commands'; + +// Alternatively you can use CommonJS syntax: +// require('./commands') diff --git a/cypress/tsconfig.json b/cypress/tsconfig.json new file mode 100644 index 000000000..f87a578b6 --- /dev/null +++ b/cypress/tsconfig.json @@ -0,0 +1,8 @@ +{ + "compilerOptions": { + "target": "es5", + "lib": ["es5", "dom"], + "types": ["cypress"] + }, + "include": ["**/*.ts"] +} diff --git a/packages/examples/basic/.babelrc b/examples/basic/.babelrc similarity index 100% rename from packages/examples/basic/.babelrc rename to examples/basic/.babelrc diff --git a/packages/examples/basic/.gitignore b/examples/basic/.gitignore similarity index 100% rename from packages/examples/basic/.gitignore rename to examples/basic/.gitignore diff --git a/examples/basic/CHANGELOG.md b/examples/basic/CHANGELOG.md new file mode 100644 index 000000000..734e536e4 --- /dev/null +++ b/examples/basic/CHANGELOG.md @@ -0,0 +1,226 @@ +# Change Log + +All notable changes to this project will be documented in this file. +See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. + +# 0.2.0-alpha.23 (2021-05-14) + + +### Features + +* **slate:** improve speed of slate/craft integration ([#241](https://github.com/prevwong/craft.js/issues/241)) ([763274c](https://github.com/prevwong/craft.js/commit/763274c4787130675127703d333ea63ee8482fb1)) + + + + + +# 0.2.0-alpha.22 (2021-04-26) + + +### Bug Fixes + +* orphaned linked nodes ([#236](https://github.com/prevwong/craft.js/issues/236)) ([65450ea](https://github.com/prevwong/craft.js/commit/65450ea97a0bbac4efc51d0306025bd07a5165bb)) + + + + + +# 0.2.0-alpha.21 (2021-03-22) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.20 (2021-03-22) + + +### Bug Fixes + +* remove slate node ([#217](https://github.com/prevwong/craft.js/issues/217)) ([9f7ec97](https://github.com/prevwong/craft.js/commit/9f7ec97e88825460054f8880bb4b5900c2776721)) + + + + + +# 0.2.0-alpha.19 (2021-03-16) + + +### Features + +* additional indicator options ([#212](https://github.com/prevwong/craft.js/issues/212)) ([0d9c6e5](https://github.com/prevwong/craft.js/commit/0d9c6e59a8725ba600d177ad5a9beec0434e640c)) + + + + + +# 0.2.0-alpha.18 (2021-03-11) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.17 (2021-03-11) + + +### Bug Fixes + +* lint ([3750b11](https://github.com/prevwong/craft.js/commit/3750b11dbe27b477820dac8c940bcb46981e6956)) + + + + + +# 0.2.0-alpha.16 (2021-02-18) + + +### Bug Fixes + +* handlers not being disabled ([#189](https://github.com/prevwong/craft.js/issues/189)) ([f9c2274](https://github.com/prevwong/craft.js/commit/f9c227415d3bc4ef0490437b16a862234c15d7f7)) + + + + + +# 0.2.0-alpha.15 (2021-02-11) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.14 (2021-02-08) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.13 (2021-02-03) + + +### Bug Fixes + +* yarn.lock ([6782edf](https://github.com/prevwong/craft.js/commit/6782edf1715a41c0f21daaeab92c5e7edb8c2f17)) + + + + + +# 0.2.0-alpha.12 (2021-01-28) + + +### Bug Fixes + +* **slate:** delete orphaned nodes ([#171](https://github.com/prevwong/craft.js/issues/171)) ([f201ddc](https://github.com/prevwong/craft.js/commit/f201ddc8a26cd09deab69220a9099bb5ff2c6973)) + + + + + +# 0.2.0-alpha.11 (2021-01-26) + + +### Bug Fixes + +* **slate:** split operation bug ([#169](https://github.com/prevwong/craft.js/issues/169)) ([9a7b3b3](https://github.com/prevwong/craft.js/commit/9a7b3b3e3a4f6d71d2ef5d9d1de1cb4d2c931696)) + + + + + +# 0.2.0-alpha.10 (2021-01-22) + + +### Bug Fixes + +* remove auto-add drag connector ([#163](https://github.com/prevwong/craft.js/issues/163)) ([60a600a](https://github.com/prevwong/craft.js/commit/60a600a8c9bc675b3715c6f5881da9574fbf3845)) + + + + + +# 0.2.0-alpha.9 (2021-01-20) + + +### Bug Fixes + +* remove slate op ([#162](https://github.com/prevwong/craft.js/issues/162)) ([a46ed6c](https://github.com/prevwong/craft.js/commit/a46ed6cd72700273279e89c13e9e7c3d4238f93c)) + + + + + +# 0.2.0-alpha.8 (2021-01-12) + + +### Bug Fixes + +* slate bugs ([#159](https://github.com/prevwong/craft.js/issues/159)) ([58af806](https://github.com/prevwong/craft.js/commit/58af80669a43bedf015d22be0a8d6be2a47de89c)) + + + + + +# 0.2.0-alpha.7 (2021-01-12) + + +### Features + +* history merge ([8016b82](https://github.com/prevwong/craft.js/commit/8016b82bf26dd208a17df59c93ed7f46cbee955f)) + + + + + +# 0.2.0-alpha.6 (2021-01-06) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.5 (2021-01-06) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.4 (2021-01-06) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.3 (2021-01-04) + +**Note:** Version bump only for package example-basic + + + + + +# 0.2.0-alpha.2 (2021-01-04) + + +### Bug Fixes + +* History throttle ([#157](https://github.com/prevwong/craft.js/issues/157)) ([bc4bcbd](https://github.com/prevwong/craft.js/commit/bc4bcbde27c6cc48ba132e07e03f0c43798f6272)) + + + + + +# 0.2.0-alpha.1 (2020-12-04) + +**Note:** Version bump only for package example-basic diff --git a/packages/examples/basic/README.md b/examples/basic/README.md similarity index 100% rename from packages/examples/basic/README.md rename to examples/basic/README.md diff --git a/packages/examples/basic/components/Header.js b/examples/basic/components/Header.js similarity index 100% rename from packages/examples/basic/components/Header.js rename to examples/basic/components/Header.js diff --git a/packages/examples/basic/components/SettingsPanel.js b/examples/basic/components/SettingsPanel.js similarity index 75% rename from packages/examples/basic/components/SettingsPanel.js rename to examples/basic/components/SettingsPanel.js index a4bb19edc..4b4640990 100644 --- a/packages/examples/basic/components/SettingsPanel.js +++ b/examples/basic/components/SettingsPanel.js @@ -9,7 +9,7 @@ import { import React from 'react'; export const SettingsPanel = () => { - const { actions, selected } = useEditor((state, query) => { + const { actions, selected, isEnabled } = useEditor((state, query) => { const currentNodeId = state.events.selected; let selected; @@ -26,10 +26,11 @@ export const SettingsPanel = () => { return { selected, + isEnabled: state.options.enabled, }; }); - return selected ? ( + return isEnabled && selected ? ( @@ -39,12 +40,19 @@ export const SettingsPanel = () => { Selected - + - {selected.settings && React.createElement(selected.settings)} +
+ {selected.settings && React.createElement(selected.settings)} +
{selected.isDeletable ? ( { connectors.create(ref, -
-
- - -
- { - sourceId && targeId ? ( - - ) - } - - ) -} -``` - -### Creating and Adding a new Node -```tsx -import {useEditor} from "@craftjs/core"; - -const Example = () => { - const { query, actions } = useEditor((state, query) => ({ - hoveredNodeId: state.events.hovered - })); - - return ( - - ) -} -``` - - -### Getting the currently selected Node's descendants -> Query methods are also accessible from within the collector function. - -```tsx -import {useEditor} from "@craftjs/core"; - -const Example = () => { - const { selectedDescendants } = useEditor((state, query) => ({ - selectedDescendants: state.events && query.getDeepNodes(state.events.selected).map(node => node.id) - })); - - return ( -
    - { - selectedDescendants && selectedDescendants.map(id =>
  • {id}
    • ) - } -
- ) -} -``` - -### Displaying Drop Indicator for the best possible drop location -```jsx -const Example = () => { - const [screenClick, setScreenClick] = useState(false); - const [sourceId, setSourceId] = useState(); - const [targetId, setTargetId] = useState(); - - const {selectedNodeId, actions, query} = useEditor((state) => ({ - selectedNodeId: state.events.selected - })); - - const disableScreenClick = useEffect((e) => { - if(e.key === "Escape") { - setScreenClick(false); - } - }, [screenClick]); - - const clickOnScreen = useEffect((e) => { - const {clientX: x, clientY: y} = e; - const dropIndicator = query.getDropIndicator(sourceId, targetId, {x, y}); - actions.setDropIndicator(dropIndicator); - }, [screenClick]); - - - useEffect(() => { - window.addEventListener("click", clickOnScreen); - window.addEventListener("keyup", disableScreenClick); - return (() => { - window.removeEventListener("click", clickOnScreen); - window.removeEventListener("keyup", disableScreenClick); - }) - }, [clickOnScreen, disableScreenClick]); - - return selectedNodeId && ( -
-

Node selected: {selectedNodeId}

-
- - -
-
- - -
- { - sourceId && targeId ? ( - - ) - } -
- ) -} -``` - - -## Legacy API -For Class Components, use `connectEditor` instead. - - - - -### Parameters - Collected", "A function that collects relevant state information from the corresponding Node. The component will re-render when the values returned by this function changes."] -]} /> - -### Injected Props - - - -### Example -```jsx -import { connectEditor } from "@craftjs/core"; - -class SidebarInner extends React.Component { - render() { - const { actions, query, enabled, currentSelectedNodeId } = this.props; - return ( -
- actions.setOptions(options => options.enabled = !enabled) - } /> - -
- ) - } -} - -export const Sidebar = connectEditor((state) => ({ - currentSelectedNodeId: state.events.selected -}))(SidebarInner); -``` diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/api/useNode.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/api/useNode.md deleted file mode 100644 index 3dabbbaf0..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/api/useNode.md +++ /dev/null @@ -1,215 +0,0 @@ ---- -id: useNode -title: useNode() -sidebar_label: useNode() ---- - -import {API, Badge} from "@site/src/components"; - - - - -A Hook that provides methods and state information related to the corresponding `Node` that manages the current component. - -```tsx -const { connectors, setProp, ...collected } = useNode(collector); -``` - -> Note: This hook can only be used within a User Component. - - -## Reference -### Parameters - Collected", "A function that collects relevant state information from the corresponding Node. The component will re-render when the values returned by this function changes."] -]} /> - -### Returns - - - HTMLElement", "Specifies the DOM that represents the User Component"], - ["drag", "(dom: HTMLElement) => HTMLElement", "Specifies the DOM that should be draggable"] - ]], - ["setProp", "(props: Object) => void", "Manipulate the current component's props"], - ["...collected", "Collected", "The collected values returned from the collector"] - ] - ] -]} /> - -> Note: `connectors` have **no** effect when used inside [Related Components](../concepts/user-components#related-components) - -## Examples - -### Collecting state information -```tsx -import cx from "classnames"; -import {useNode} from "@craftjs/core"; - -const Example = () => { - const { isHovered, amIBeingDragged } = useNode((node) => ({ - isHovered: node.events.hovered, - amIBeingDragged: node.events.drag, - - })); - - return ( -
- Yo -
- ) -} -``` - -### Connectors -Connectors must receive a HTML element which can be obtained via an element's `ref`. - - -Typically, you would want to chain the `connect` and `drag` connectors to the root element of your component. This way, users would be able to drag anywhere within the DOM to move the component. -```jsx -const Example = () => { - const { connectors: {connect, drag} } = useNode(); - - return ( -
connect(drag(ref))}> -
Hi world
-
- ) -} -``` - -Alternatively, you could place the `drag` connector in a child element too. - -In the following example, we specified it on the `a` element. Now, users will need to drag the `a` element if they wish to move the component. -```jsx -const Example = () => { - const { connectors: {connect, drag} } = useNode(); - - return ( - - ) -} -``` - -You could place the connectors on a React Component as well. However, the component must expose/forward its DOM in its `ref` -```jsx -const CustomDragHandler = React.forwardRef((props, ref) => { - return( - Drag me to move this component - ) -}); - -const Example = () => { - const { connectors: {connect, drag} } = useNode(); - - return ( -
-
Hi world
- Drag me to move this component -
- ) -} -``` - -### Usage within child components -Since User Components are contextually bounded by the `Node` that they are being managed by, thus `useNode` can be used anywhere **within** the component tree. - -In the previous example, we didn't actually need to forward refs from `CustomDragHandler` since it's bounded by the same `Node` as its parent. Instead, we can just use the connectors from `useNode` directly. - - -```jsx -const CustomDragHandler = () => { - const {drag} = useNode(); - return( - Drag me to move this component - ) -}; - -const Example = () => { - const { connectors: {connect} } = useNode(); - - return ( -
-
Hi world
- -
- ) -} -``` - - - -### Manipulating state - -```jsx -const Example = ({someProp}) => { - const { connectors: {connect, drag} } = useNode(); - - return ( -
-
Hi world
- Drag me to move this component - { - setProp(props => { - props.someProp = e.target.value; - }); - }} /> -
- ) -} -``` - - -## Legacy API -For Class Components, use `connectNode` instead. - - - - -### Parameters - Collected", "A function that collects relevant state information from the corresponding Node. The component will re-render when the values returned by this function changes."] -]} /> - -### Injected Props - - - -### Example -```jsx - -import {connectNode} from "@craftjs/core"; -class ButtonInner extends React.Component { - render() { - const { connectors: {connect, drag}, isHovered, ...compProps } = this.props; - const { text, color } = compProps; - - return ( - - ); - } -}; - -export const Button = connectNode((node) => ({ - isHovered: node.events.hovered -}))(ButtonInner); - -``` diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/editor-components.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/editor-components.md deleted file mode 100755 index 3ba31a6d7..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/editor-components.md +++ /dev/null @@ -1,130 +0,0 @@ ---- -id: editor-components -title: Interacting with the Editor ---- - - -Previously, we have looked at User Components and how to write them, but what about all the other components that are integral to our page editor like a Toolbar for users to edit components, or maybe a layers panel? - -The `useEditor` hook allows us to read and manipulate the entire editor's internal state. Essentially, this is similar to the `useNode` hook we have seen previously, except this deals with the entire editor rather than with a particular `Node`. - -```jsx -const { actions, connectors, ...collected } = useEditor((state) => {}); -``` - -> Note: Unlike `useNode` which can be only used inside User Components, `useEditor` can be used anywhere within the Craft context, including User Components. - - -## Getting state information -Similar with the `useNode`, we can specify a collector function to the `useEditor` hook to retrieve information from the internal state. - -```tsx -const App = () => { - const { hoveredNodeName } = useEditor((state: Node) => { - const currentlyHoveredId = state.events.hovered; - return { - hoveredNodeName: state.nodes[currentlyHoveredId].displayName - } - }) - return ( -

The component being hovered is: {hoveredNodeName}

- ) -} -``` - - -## Connectors -With`useEditor`, you can add connectors to DOM elements anywhere in the editor to make use of the editor's internal events. - -Let's say, maybe you are creating a layers panel to display all nodes as Photoshop-like layers (wink wink, `craftjs-layers`) and would like to change the particular Node's event state when the user clicks/hovers/drags your layers. - -```jsx -const LayerItem = (nodeId) => { - const { connectors: { select }} = useEditor(); - - return ( - - ); -} -``` -Or, maybe drag a button to create a new instance of a User Component -```jsx -const DragToCreate = (nodeId) => { - const { connectors: { drag }} = useEditor(); - - return ( - - ); -} -``` - - - - -## Manipulating state -We can use the `actions` provided to manipulate the editor's internal state - -```jsx -const DeleteButtonThingy = () => { - const { actions, selectedNodeId } = useEditor((state) => ({ - selectedNodeId: state.events.selected - })); - - return ( -
- -
- ) -} -``` - -## Querying - -What if you need to know if two nodes are compatible, how to get all parents of a Node or simply deserialize all Nodes? Queries are methods that provide helpful information based on the editor's state. - - -```jsx -const Sidebar = () => { - const {query} = useEditor(); - return ( - - ) -} - -``` -Queries are also accesible via the `useEditor` collector function. Let's look at an example where we build a component that returns all the descendants of the current selected Node: - -```jsx -const ShowMeMyDescendants = () => { - const { allDescendants } = useEditor((state, query) => { - const selectedNodeId = state.events.selected; - let allDescendants = false; - - if (selectedNodeId) allDescendants = query.node(selectedNodeId).decendants(); - - return { allDescendants } - }); - - return allDescendants ? ( -
- { - allDescendants.map(node => -
  • {node.id}
    • - ) - } -
    - ) : null -} - -``` - diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/nodes.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/nodes.md deleted file mode 100755 index 92c41e3ef..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/nodes.md +++ /dev/null @@ -1,69 +0,0 @@ ---- -id: nodes -title: Nodes ---- - -## User Elements -User Elements are React Elements which the end user will have the ability to manipulate. In other words, these are the elements which you will want your users to edit, drag and/or drop in your editor. - -Just like React Elements, these can be either simple HTML tags or React Components. We'll refer to User Elements which are React Components simply as *User Components*. - - -## Node -Craft.js maintains an internal state comprised of objects called Nodes which represent and manage User Elements that are rendered in the editor. These Nodes contain information such as the element type, current props, DOM element, parent Node and so on. Hence, every User Element is rendered and managed by their corresponding Node. - -## Canvas -A Canvas is a special type of Node which is able to store child Nodes. The child Node's User Element will be made draggable. - -Essentially, if a User Element is managed by a Canvas node, that would effectively turn that component into a droppable region where users can drag and drop components into and out of. - - -In a nutshell: -- A Canvas node defines a droppable region -- A Node that is a child of a Canvas is draggable -- A Canvas node itself is not draggable unless it is a child Node of parent Canvas. - - -## How Nodes are created -We know what Nodes are and that every User Component must be represented by a `Node`, but how do we actually represent our React elements as Nodes? - -`` is a React component provided by Craft.js which automatically creates a Canvas node and a Node for each of its immediate child. - -Let's say we want to create a droppable region, `div` with its immediate children being made draggable: -```jsx - // A Canvas node with the type div; -

    Hi

    // Node of the type h1; draggable! - Hey // Node of the type MyComp; draggable! -     -``` -> The `is` prop specifies the type of User Element to create; it can be either a HTML tag or a User Component - -In the above example, using the `` component, we've created a Canvas node of the type `div` and additionally created subsequent child Nodes of the type `h1` and `MyComp`. - -Since our `div` element is now handled by a Canvas node, therefore it is now a droppable region. On the other hand, since `h1` and `MyComp` are child Nodes of a Canvas, they are now draggable. - -> The `` component only represents its immediate children as Nodes. Hence any subsequent grandchild components are not a `Node` and will not be draggable. - -```jsx - // A Canvas node with the type div, I am not draggable btw. -
    // Node of the type div; draggable -

    Hi

    // NOT A NODE, so I am not draggable :( -
    - // Canvas Node of the type p; droppable and draggable! -

    Hi

    // Node of the type h2; draggable! -     -     -``` - -Let's look at another example: -```jsx {2,7} - -

    Hi

    -     - -const Container = ({children}) => -
    - {children} -
    -``` -Here, we have created a Canvas node of the type `Container` which is a User Component. Our `Container` element is now managed by a Canvas node, thus is now a droppable region; all items dropped in its location will be rendered in its `children` prop. diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/serializing.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/serializing.md deleted file mode 100755 index 2a20d8bf9..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/serializing.md +++ /dev/null @@ -1,57 +0,0 @@ ---- -id: serializing -title: Serializing ---- - -### Serializing -We can serialize the editor's current state of Nodes into JSON by calling the `serialize` method provided by the `useEditor` hook -```jsx -const Toolbar = () => { - const { query } = useEditor(); - - return ( - console.log(query.serialize())}>Serialize - ) -} -``` - -## Resolvers -Craft.js exports the nodes in its internal state into a serialzable JSON format. For this to be possible, complex objects such as functions cannot be included - which means User Components cannot be serialised. - -To overcome this is why when setting up Craft.js with your React application, one of the first things you have to do is to specify a map of user components in the `resolver` prop of the `Manager` component. - - -```jsx -import {Text, Hero, Container} from ".../myproject/components"; - -const App = () => { - return ( - - - -

    Hi

    - -     - -     - ) -} -``` - -Given the above example, when a `Node` that is of the type `Text` is serialised, it will return something like this: -```json -"node-randomId": { - "type": { - "resolvedName": "MyText" - }, - "props": { - "text" : "Hi World!" - }, - "parent": "canvas-ROOT", - "displayName": "Card" - ... -} -``` -Notice how the `resolvedName` is `MyText` rather than the name of the component, `Text`. This is because in our `resolver`, we mapped `MyText` to our Text component. Now, when we deserialize - Craft.js is easily able to find `MyText` in our resolver, and knows the component it refers to. diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/user-components.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/user-components.md deleted file mode 100755 index d97d2df24..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/concepts/user-components.md +++ /dev/null @@ -1,300 +0,0 @@ ---- -id: user-components -title: User Components ---- - -import {API} from "@site/src/components"; - -User Components are intended to be written just like any other React Component. - -Let's start with a simple Hero component: - -```jsx -const Hero = ({title}) => { - return ( -
    -

    {title}

    -
    - ) -} -``` -Now, let's actually get the component to work with the editor. The `useNode` hook provides us with several information and methods related to the corresponding `Node` that manages the component. - -```jsx -const { connectors: {connect, drag}, setProp, ...collected } = useNode((node) => {}); -``` - -Additionally we can pass configuration values via the static `craft` property: -```jsx -const Hero = () => {...} -Hero.craft = { - defaultProps: {}, - rules: { - canDrag: () => true, - canMoveIn: () => true, - canMoveOut: () => true - }, - related: {} -} -``` - -We'll explore each of these values in the following sections. - -## Connectors -The first thing we would want to do is to actually let Craft.js to manage the DOM for our component. - -- `connect`: specifies the DOM that represents the User Component. If the component's corresponding Node is a Canvas, then this also defines the area that is droppable. -- `drag`: specifies the DOM element that should be made draggable. When the user drags this element, it'll be considered as dragging the entire component, therefore moving the entire component to the drop location. This connector only takes effect if the component's corresponding node is a Canvas Node. - -```jsx {17,18,21} -const Hero = ({title, children}) => { - const { connectors: {connect, drag} } = useNode(); - return ( -
    connect(drag(dom))}> -

    {title}

    -
    - {children} -
    -
    - ) -} - -const App = () => { - return ( - - - // (i) - // (ii) -

    Hi

    -     - // (iii) -

    Hi

    -     -     - -     - ) -} -``` - -- i. `Hero` is being rendered with a Canvas Node, thus it defines a droppable region. However, since it is not a child of a Canvas Node, it is not draggable (the `drag` handler will not do anything). -- ii. `Hero` is an immediate child of a Canvas Node; it is draggable. -- iii. `Hero` is an immediate child of a Canvas Node and is rendered with a Canvas Node - it is both draggable and droppable. - -## Props manipulation -You've probably seen page editors where you could directly interact with the components and manipulate them. For instance, drag to resize an image or visually edit a text. This is easily achievable with Craft.js as well. - -Since components are managed by their corresponding `Node` which contains information including the component's props, thus we can call the `setProp` method to update the prop values stored in the `Node`. In turn, this will re-render the component with its updated values. - -```jsx -const Hero = ({title}) => { - const { connectors: {connect, drag}, setProp } = useNode(); - - return ( -
    connect(drag(dom))}> -

    { - setProp(props => { - props.title = e.target.innerText; - }) - }}>{title}

    -
    - ) -} -``` - -In the above example, we have updated our `h2` element to be content editable and added an event handler to update the `title` prop as the user visually enters in a new value. - -## Collecting Node's state -The information stored in a corresponding `Node` could be useful in helping you build more usable components. We can retrieve information from a `Node` by passing a collector function to the `useNode` hook. Every time the values we retrieved via the collector function changes, our component will re-render. This is very much similar to Redux's `connect` pattern. - - -For instance, let's say we would like to enable the content editable text from the previous section only when the user has actually clicked on our component: - -```jsx -const Hero = ({title}) => { - const { connectors: {connect, drag}, setProp, isClicked } = useNode((node) => ({ - isClicked: node.events.selected - })); - - return ( -
    connect(drag(dom))}> -

    { - setProp(props => { - props.title = e.target.innerText; - }) - }}>{title}

    -
    - ) -} -``` - -## Default Props -While it's not necessary as we could simply define default parameters (e.g.: ES6 defaults) directly within our components, these default values will not actually be recorded into the component's corresponding `Node`, which could leave us with a lot of empty prop values when we wish to retrieve the `Node` for a component when building other parts of our editor (eg: a Toolbar for editing a component's values). - -To prevent that, we can explicitly specify default prop values via the `craft.defaultProps` like the following: - -```jsx -const Hero = ({text}) => { /** same as previous example **/ } -Hero.craft = { - defaultProps: { - text: "Hi there!" - } -} -``` - -## Specify drag/drop rules -You may want to restrict how your components are dragged or what goes in and out of your component. These rules can be specified in the static `craft.rules`. - -Let us write a (pretty strange) rule for our Hero component which users can only drag if they change the `text` prop to "Drag": -```jsx -const Hero = ({text}) => { /** same as the previous example **/ } -Hero.craft = { - defaultProps: { /** same as the previous example **/ }, - rules: { - canDrag: (node) => !!node.data.props.text == "Drag" - } -} -``` - - -## Related Components -What happens if you need to design some component to complement our user component? For instance, if we were planning on building a Toolbar somewhere in our page editor, we would like the Toolbar to display a bunch of text inputs to allow the user the edit the currently selected component. It would be great if we could retrieve a specific component that has all the relevant inputs for the user to edit the currently selected component. - - -This is where related components become useful. These components share the same corresponding `Node` as the actual user component, hence the `useNode` hook that we have been using all this while will be made available to these components as well. - -```jsx -const Hero = ({text}) => { /** same as the previous example **/ } -Hero.craft = { - related: { - toolbar: HeroToolbarSettings - } -} - -const HeroToolbarSettings = () => { - const { setProp, text } = useNode((node) => ({ - text: node.data.props.text - })); - - return ( -
    -

    Hero settings

    - - setProp(prop => prop.text = e.target.value) - } - /> -
    - ) -} -``` -Now, let's say we have a Toolbar component somewhere in our editor. We can easily retrieve the related component as such: - -```jsx -const Toolbar = () => { - const { selectededNodeId, toolbarSettings } = useEditor((state) => ({ - selectededNodeId : state.event.selected, - toolbarSettings: state.nodes[state.events.selected].related.toolbar - })); - return ( -
    -

    My Awesome Toolbar

    - { - selectededNodeId && toolbarSettings ? - React.createElement(toolbarSettings) - : null - } -
    - ) -} - -``` - -## Defining droppable regions -Let's say we are creating a Hero component that has two sections where the users could drop other user elements into. - -```jsx -const Hero = ({title}) => { - return ( -
    -

    {title}

    -
    -

    Yo

    -
    - I need some coffee to continue writing this -
    -

    Hi

    -
    -
    - ) -} -``` - -Previously, we discussed how `` creates a droppable Canvas node; that concept is applied universally in Craft.js. Hence, we just have to wrap our `section` elements in the example above with a `Canvas`. - -```jsx {5,9} -const Hero = ({title}) => { - return ( -
    -

    {title}

    - -

    Yo

    -     - I need some coffee to continue writing this - -

    Hi

    -     -
    - ) -} -``` - -But wait, what if we want to define rules for these two new droppable regions? - -The `is` prop of the `` component is used to specify the `type` of the User Element for the Canvas Node. Hence, instead of specifying a simple DOM element which we don't have much control over, let's specify a brand new User Component. - - -```jsx {1-23,29,33} -const HeroHeader = ({children}) => { - return ( -
    - {children} -
    - ) -} - -HeroHeader.craft = { - rules : {...} -} - -const HeroFooter = ({children}) => { - return ( -
    - {children} -
    - ) -} - -HeroFooter.craft = { - rules : {...} -} - -const Hero = ({title}) => { - return ( -
    -

    {title}

    - -

    Yo

    -     - I need some coffee to continue writing this - -

    Hi

    -     -
    - ) -} -``` - -`HeroHeader` and `HeroFooter` are User Components, so we can now design and configure them just like any other User Components. On that note, don't forget that you will need to include these in the `resolver` as well. diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/dev.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/dev.md deleted file mode 100644 index 956d8d711..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/dev.md +++ /dev/null @@ -1,263 +0,0 @@ ---- -id: dev -title: Craft.js - Build any page editor with React ---- - - - -You know a web application is fancy when it has a page editor. Without a doubt, a page editor helps boost user experience significantly. If you're a frontend developer and have been tasked to be build one before, then you know precisely the difficulties and challenges of building one. - -Existing libraries such as Grape.js or react-page are great for a working out-of-the-box page editor solution. However, as soon as you need to customise the look and feel of the page editor itself, you will find yourself hacking in the library's code. - - -## Introducing Craft.js -Craft.js is a React framework to build any type of page editor. Instead of providing a working page editor implementation with a user interface, Craft.js provides an abstraction for you to implement your own page editor upon. It comes backed-in with an extensible drag-n-drop system which handles the way React elements should be rendered/updated, and a cohesive API to interact with the editor which you can additionally implement your own features on top of. - -### TL;DR -- Design your own user interface for your page editor -- Write React components that end-user could edit -- Govern drag-and-drop conditions for your components -- Control how your components should be edited. From simple text fields to content editables and drag to resize; if you can do it in React, then you can do it with Craft.js. - - -## Editable React Components -Let's start with a simple Card component like this: - -```jsx -const Card = ({title}) => { - return ( -
    -

    {title}

    -
    -

    Hi

    -
    -
    - ) -} -``` - -First, to integrate it with with Craft.js' drag-and-drop system, we just need to do the following modifications: - -```jsx -import {useNode} from "@craftjs/core"; - -const Card = ({title}) => { - const { connectors: { connect, drag } } = useNode(); - return ( -
    connect(drag(dom))}> -

    {title}

    -
    -

    Hi

    -
    -
    - ) -} -``` - -What's happening here? -- We passed the `connect` connector to the root element of our component; this tells Craft.js that this element represents the `Card` component. Hence, the dimensions of the specified element will be taken into consideration during drag and drop events. -- Then, we also passed `drag` connector to the same root element; this adds the drag handlers to the DOM. If the component is rendered as the child of a ``, the user will be able to drag this element and it will move the entire Text component. - - -Next, we might want to be able to control the drag-n-drop rules of our Card component. For example, let's say we only want our Card component to be draggable as long as its `title` prop is not "No Drag". We can achieve this easily as such: -```jsx -const Card = () => {...} - -Card.craft = { - rules: { - canDrag: (node) => node.data.props.title != "No Drag" - } -} -``` - -#### Droppable regions -Next, let's take a look at the `#p-only` element we specified in our Card component. What if we want this area to be droppable where only `p` can be dropped? - -This is where the`` component provided by Craft.js becomes useful. It defines a droppable region where each of its immediate child is draggable. - - -```jsx -import {useNode, Canvas} from "@craftjs/core"; - -const Card = ({title}) => { - const { connectors: { connect, drag } } = useNode(); - return ( -
    connect(drag(dom))}> -

    {title}

    - -

    Hi

    -     -
    - ) -} -``` -Your next question might be about how we control our newly created droppable region. The `` component accepts an `is` prop which can be either a HTML element or a React component (by default, it's a `div`). So, if we supply a React component, we can essentially achieve the same design flexibility as we have with our Card component: - -```jsx -import {useNode, Canvas} from "@craftjs/core"; - -const Container = ({children}) => { - const { connectors: {connect} } = useNode(); - return ( -
    connect(dom)}> - {children} -
    - ) -} - -Container.craft = { - rules: { - canMoveIn: (incomingNode) => incomingNode.data.type == "p" - } -} - -const Card = ({title}) => { - const { connectors: { connect, drag } } = useNode(); - return ( -
    connect(drag(dom))}> -

    {title}

    - -

    Hi

    -     -
    - ) -} -``` - -Let's break this down a bit. Our `` component is being rendered as a droppable region. This means, all dropped elements will be rendered in the component's `children` prop. Next, we also specified the `connectors` just as we did previously. This time, we specified a `canMoveIn` rule where only elements with the `p` tag will be accepted into the component. - -## Control editing behaviours -Of course, any page editor must allow the end-user to edit the elements that are rendered. With Craft.js, you are in control of this as well. - -Let's make our `h2` element content editable so our users could visually edit the `title` prop: - -```jsx -const Card = ({title}) => { - const { connectors: { connect, drag }, setProp } = useNode(); - return ( -
    connect(drag(dom))}> -

    setProp(e.target.innerText)}>{title}

    - ... -
    - ) -} -``` -> In a real application, you may want to consider using react-contenteditable - -Obviously, we do not want the element to be content editable all the time; perhaps only when our Card component is actually clicked: - -```jsx -const Card = ({title}) => { - const { connectors: { connect, drag }, setProp, isSelected } = useNode((node) => ({ - isSelected: node.events.selected - })); - - return ( -
    connect(drag(dom))}> -

    setProp(e.target.innerText)}>{title}

    - ... -
    - ) -} -``` -What we are doing is essentially accessing Craft's internal state and retrieving information about the current instance of our Card component. In this case, we are retrieving the `selected` event state which returns `true` when the user clicks on the DOM specified by the `connect` connector of the Component. - -## Your page editor, your user interface - -Essentially, Craft.js exposes these few React components: -- `Editor` creates the Editor context and sets everything up -- `Frame` defines the editable area - -As you may have noticed, none of these are UI components. Instead, they are intended to be plugged into any user interface you would like to implement for your page editor. - -Let's take a look at a super simple interface that we could design: - -```jsx -// pages/index.js -import React from 'react'; - -export default function App() { - return ( - <> -

    My page editor

    - {/* sets everything up */ } -
    - {/* This part is now editable */ } - { /* Creates a gray droppable div */ } -

    Drag me around

    -

    I'm draggable too - {/* a div that is both droppable and draggable */} -

    Hi

    {/* a draggable h2 */} -     - - -
    -     - - ); -} -``` - -### Interacting with the editor -Your user interface will most likely need to display some information or perform certain editor-related actions. - -Let's say we want to design a Toolbar component that does the following things: - - Tells us the the type of the currently selected element - - Has a button to save the current editor state - - Has another button to load the last saved editor state - -```jsx -import React, {useState} from 'react'; - -export default function App() { - return ( - <> -

    My page editor

    - - {/* Add this */} -
    - - ... - -
    -     - - ); -} - -const Toolbar = () => { - const [savedState, setSavedState] = useState(); - const { selectedType, actions, query } = useEditor(state => { - const selectedId = state.events.selected; - return { - selectedType: selectedId && state.nodes[selectedId].data.type - } - }); - - return ( - - ) -} -``` - -Let's break this down: -- First, we access the editor's state to retrieve the type of the currently selected element -- Then, when the "Save Checkpoint" button is clicked, we use the `serialize` query which tells the editor to return its state in a serialised JSON form. We then save the JSON output in our component's state -- Once we have the JSON, we display the "Load from checkpoint" button. When this button is clicked, we simply call the `deserialize` editor action which essentially returns the editor to the state stored in the JSON output. - - -## Closing words -This has been a high-level overview of Craft.js and we've only covered some very basic examples. We've seen how we could easily control almost every aspect of the page editor experience. Hopefully, this article has given you an idea on the possibilities of what you can do with Craft.js. diff --git a/packages/docs/versioned_docs/version-0.1.0-beta.6/guides/basic-tutorial.md b/packages/docs/versioned_docs/version-0.1.0-beta.6/guides/basic-tutorial.md deleted file mode 100755 index 7db046ff2..000000000 --- a/packages/docs/versioned_docs/version-0.1.0-beta.6/guides/basic-tutorial.md +++ /dev/null @@ -1,1061 +0,0 @@ ---- -id: basic-tutorial -title: Basic Tutorial ---- - -import {Image} from "@site/src/components"; - -Live Demo -View Code - -## Overview -In this tutorial, we'll be designing a simple page editor. It's recommended that you have a basic to intermediate workings of React and it'd be even better if you first have a quick glance at the [Core Concepts](../concepts/nodes.md) and come back here. If you are feeling adventurous, that's fine too. - - - - -## Installation - -```bash -yarn add @craftjs/core -``` - -or with npm: -```bash -npm install --save @craftjs/core -``` - - -## Designing a user interface -With Craft.js you decide how your editor should look and function. So, let's build a user interface for our page editor. We'll add the page editor functionalities later. - - -To make our lives easier, we'll use some external packages for designing our user interfaces. -```bash -yarn add @material-ui/core react-contenteditable material-ui-color-picker -``` - -### User Components -Let's first create the User Components - the components that our end users will be able create/edit/move around. - -#### Text -```jsx -// components/user/Text.js -import React from "react"; - -export const Text = ({text, fontSize}) => { - return ( -
    -

    {text}

    -
    - ) -} -``` - -#### Button -```jsx -// components/user/Button.js -import React from "react"; -import {Button as MaterialButton} from "@material-ui/core"; - -export const Button = ({size, variant, color, children}) => { - return ( - - {children} - - ) -} -``` - -#### Container -We will also create a Container component which would allow our users to change its background colour and padding. - -```jsx -// components/user/Container.js -import React from "react"; -import { Paper } from "@material-ui/core"; - -export const Container = ({background, padding = 0, children}) => { - return ( - - {children} - - ) -} -``` - -#### Card -Now, let's create another user component that will be more advanced. It will be composed of the Container component we made earlier, and it will contain two droppable regions; one for text and another for buttons. - -```jsx -// components/user/Card.js -import React from "react"; -import { Text } from "./Text"; -import { Button } from "./Button"; -import { Container } from "./Container"; - -export const Card = ({background, padding = 20}) => { - return ( - -
    - - -
    -
    -
    -     - ) -} - -``` - -### The Editor -#### Toolbox -Let's build a "toolbox" which our users would be able to drag and drop to create new instances of those User Components we just defined. - -```jsx -// components/Toolbox.js -import React from "react"; -import { Box, Typography, Grid, Button as MaterialButton } from "@material-ui/core"; - -export const Toolbox = () => { - return ( - - - - Drag to add - - - Button - - - Text - - - Container - - - Card - - - - ) -}; -``` - -#### Settings Panel -We would also want to create a section here where we can display a bunch of settings which our users could use to edit the props of the user components. - -For now, let's just put in some dummy text fields. We'll revisit this in the later sections. - -```jsx -// components/SettingsPanel.js -import React from 'react'; -import { Box, Chip, Grid, Typography, Button as MaterialButton, FormControl, FormLabel, Slider } from "@material-ui/core"; - -export const SettingsPanel = () => { - return ( - - - - - - Selected - - - - - - Prop - - - - Delete - - - - ) -} -``` - -#### Top bar -Let's design a section that is going to contain a switch for users to disable the editor's functionality and also a button that is simply going to display the serialized output in the browser's console. - -```jsx -// components/Topbar.js -import React from "react"; -import { Box, FormControlLabel, Switch, Grid, Button as MaterialButton } from "@material-ui/core"; - -export const Topbar = () => { - return ( - - - - } - label="Enable" - /> - - - Serialize JSON to console - - - - ) -}; -``` - -#### Putting it all together -Now, let's put together our entire React application. - -```jsx -// pages/index.js - -import React from 'react'; -import {Typography, Paper, Grid} from '@material-ui/core'; - -import { Toolbox } from '../components/Toolbox'; -import { SettingsPanel } from '../components/SettingsPanel'; -import { Topbar } from '../components/Topbar'; - -import { Container } from '../components/user/Container'; -import { Button } from '../components/user/Button'; -import { Card } from '../components/user/Card'; -import { Text } from '../components/user/Text'; - -export default function App() { - return ( -
    - A super simple page editor - - - - - - - - - - - - - - -
    - ); -} - -``` - - - - - - -## Implementing Craft.js -Up to this point, we have made a user interface for our page editor. Now, let's get it to work! - -### Setup -- First wrap our application with `` which sets up the Editor's context. We'll also need to specify the list of user components in the `resolver` prop for Craft.js to be able to (de)serialize our User Components. - -- Then wrap the editable area with ``and `` - - `` passes the rendering process to Craft.js. - - `` creates a droppable region where its immediate children are draggable. - - -```jsx {19,22,23,27,29-31,40} -// pages/index.js -import React from 'react'; -import {Typography, Paper, Grid} from '@material-ui/core'; - -import { Toolbox } from '../components/Toolbox'; -import { SettingsPanel } from '../components/SettingsPanel'; - -import { Container } from '../components/user/Container'; -import { Button } from '../components/user/Button'; -import { Card } from '../components/user/Card'; -import { Text } from '../components/user/Text'; - -import {Editor, Frame, Canvas} from "@craftjs/core"; - -export default function App() { - return ( -
    - A super simple page editor - - - - - - - - - - - - - - - - - - - - - - -
    - ); -} -``` - -Every element that is rendered in `` is managed by an object in the editor's internal state called a `Node` which describes the element, its events, and props among other things. Whether an element is draggable or droppable or not depends on the type of `Node` that manages it. - -- If the `Node` is a Canvas, then it's droppable -- If the `Node` is an immediate child of a Canvas, then it's draggable. - -```jsx -// Explanation - - // Canvas Node of type Container, droppable - // Node of type Card - // Node of type Button, draggable - // Node of type Text, draggable - // Canvas Node of type Text, droppable and draggable - // Node of type Text, draggable - - - -``` - -If you refreshed the page, you will notice that absolutely nothing has changed - and that's a good thing! - -### Enabling Drag and Drop -Inside a User Component, we have access to the `useNode` hook which provides several information and methods related to the corresponding `Node`. - -The first thing we will need to do is to let Craft.js to manage the DOM of our component. The hook provides `connectors` which act as a bridge between the DOM and the events in Craft.js: - - -```jsx {4,7,10} -// components/user/Text.js -import React from "react"; -import { Typography } from "@material-ui/core"; -import { useNode } from "@craftjs/core"; - -export const Text = ({text}) => { - const { connectors: {connect, drag} } = useNode(); - return ( -
    connect(drag(ref))} - > -

    {text}

    -
    - ) -} -``` -Let's break this down a little: -- We passed the `connect` connector to the root element of our component; this tells Craft.js that this element represents the Text component. If the component's corresponding Node is a Canvas, then this also defines the area that is droppable. -- Then, we also passed `drag` connector to the same root element; this adds the drag handlers to the DOM. If the component's Node is a child of a Canvas, then the user will be able to drag this element and it will move the entire Text component. - -We can also specify additional configuration to our component via the `craft` prop. Let's define drag-n-drop rules for our Text Component: -```jsx -export const Text = () => {...} -Text.craft = { - ... - rules: { - canDrag: (node) => node.data.props.text != "Drag" - } -} -``` -Our Text component can now only be dragged if the `text` prop is not set to "Drag" 🤪 - -Nice, now let's enable drag-n-drop for the other User Components: -```jsx {3,5} -// components/user/Button.js -export const Button = ({size, variant, color, children}) => { - const { connectors: {connect, drag} } = useNode(); - return ( - connect(drag(ref))} size={size} variant={variant} color={color} > - ... - - ) -} -``` - -```jsx {3,5} -// components/user/Container.js -export const Container = ({background, padding = 0, children}) => { - const { connectors: {connect, drag} } = useNode(); - return ( - connect(drag(ref))} style={{ background, padding: `${padding}px`}}> - ... - - ) -} -``` - -```jsx -// components/user/Card.js (No changes) - -// It's not necessary to add connectors for our Card component since it's a composition of our Container component - which already has connectors applied. -export const Card = ({background, padding = 0}) => { - return ( - - ... - - ) -} -``` -At this point, you could refresh the page and you would be able to drag stuff around. - - - -#### Defining Droppable regions -Of course, our Card component is supposed to have two droppable regions. Remember how `` defined a droppable region earlier in our application? We can do the same here insde our Card component. - -```jsx {2,8,11,12,14} -// components/user/Card.js -import {useNode, Canvas} from "@craftjs/core"; - -export const Card = (({bg, padding})) => { - return ( - - - - - - -